CPL
/
geboshi_V2
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
革博士V2程序
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
5 提交
2 分支
904 MiB
 
目录树: 1020667987
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '1020667987'
${ noResults }
geboshi_V2/LeatherProject/GeBoShi/SysCtrl/SysMgr.cs

4051 行
198 KiB
原始文件 Blame 文件历史 

  1. #define Online

  2. #define Online_defect

  3. //#define Online_One

  4. using BarTenderPrint;

  5. using CCWin.SkinControl;

  6. using CCWin.Win32;

  7. using CCWin.Win32.Const;

  8. using DocumentFormat.OpenXml.Spreadsheet;

  9. using GeBoShi.ImageDefect;

  10. using GeBoShi.UI.InageShow;

  11. using HalconDotNet;

  12. using HZH_Controls;

  13. using HZH_Controls.Forms;

  14. using MaiMuControl.Device;

  15. using MaiMuControl.Device.CamDev;

  16. using MaiMuControl.Device.IOCardDev;

  17. using MaiMuControl.Device.IOCardDev.Advantech;

  18. using MaiMuControl.Device.LightDev;

  19. using MaiMuControl.Device.LightDev.CST;

  20. using MaiMuControl.Device.LightDev.Rsee;

  21. using MaiMuControl.Device.PlcDev;

  22. using MaiMuControl.SysStatusMgr.CloudMgr;

  23. using MaiMuControl.SysStatusMgr.StatusMgr;

  24. using MaiMuControl.SysStatusMgr.UserMgr;

  25. using MaiMuControl.Utils;

  26. using Models;

  27. using Newtonsoft.Json;

  28. using Newtonsoft.Json.Linq;

  29. using OpenCvSharp;

  30. using OpenCvSharp.Extensions;

  31. using S7.Net;

  32. using SqlSugar;

  33. using System;

  34. using System.Collections;

  35. using System.Collections.Concurrent;

  36. using System.Collections.Generic;

  37. using System.Data;

  38. using System.Diagnostics;

  39. using System.Drawing;

  40. using System.Drawing.Imaging;

  41. using System.IO;

  42. using System.IO.Ports;

  43. using System.Linq;

  44. using System.Net.Mail;

  45. using System.Threading;

  46. using System.Threading.Tasks;

  47. using System.Windows.Forms;

  48. using System.Windows.Forms.DataVisualization.Charting;

  49. using System.Windows.Forms.VisualStyles;

  50. using ToolKits.Disk;

  51. using static System.Windows.Forms.VisualStyles.VisualStyleElement.TaskbarClock;

  52. 

  53. namespace GeBoShi.SysCtrl

  54. {

  55.     /// <summary>

  56.     /// 主系统控制

  57.     /// </summary>

  58.     public class SysMgr

  59.     {

  60.         #region singleton实例化

  61.         private static SysMgr _instance;

  62.         private static readonly object _lock = new object();

  63.         public static SysMgr Instance

  64.         {

  65.             get

  66.             {

  67.                 if (_instance == null)

  68.                 {

  69.                     lock (_lock)

  70.                     {

  71.                         if (_instance == null)

  72.                         {

  73.                             _instance = new SysMgr();

  74.                         }

  75.                     }

  76.                 }

  77.                 return _instance;

  78.             }

  79.         }

  80.         #endregion

  81. 

  82.         #region 私有

  83.         //系统状态

  84.         private StatusMgr statusMgr;

  85.         public StatusMgr StatusMgr { get { return statusMgr; } }

  86.         //用户管理

  87.         private UserMgr userMgr;

  88.         public UserMgr UserMgr { get { return userMgr; } }

  89. 

  90.         //系统配置管理

  91.         private ConfMgr confMgr;

  92. 

  93.         //图像处理

  94.         private DefectLib defectLib;

  95.         public DefectLib DefectLib { get { return defectLib; } }

  96. 

  97.         //产品检测列表

  98.         private List<string> productCodeList = new List<string>();

  99.         public List<string> ProductCodeList { get { return productCodeList; } }

  100. 

  101.         //产品ID列表

  102.         private List<int> productIdList = new List<int>();

  103.         public List<int> ProductIdList { get { return productIdList; } }

  104. 

  105.         /// <summary>

  106.         /// 当前产品

  107.         /// </summary>

  108.         private Models.Product CurrProductModel = null;

  109. 

  110.         //数据锁

  111.         private object lockCurrKey = new object();

  112.         //当前运行数据key

  113.         private int currKey = 0;

  114.         //线程管控

  115.         private Hashtable htTask = new Hashtable();//默认单线程写入不用lock, 多线程安全同步读取用Synchronized 

  116. 

  117.         //是否处理完成

  118.         private bool _isDefect = false;

  119.         //计算速度用，暂停时停止计数 

  120.         private Stopwatch pStopWatch = new Stopwatch();

  121.         //计算速度用，计算实时速度 

  122.         private Stopwatch pRunSpeedWatch = new Stopwatch();

  123. 

  124.         private object lock_defectPuase = new object();

  125.         /// <summary>

  126.         /// 二次判定缺陷

  127.         /// </summary>

  128.         private List<DefectInfo> defectPuaseList = new List<DefectInfo>();

  129.         /// <summary>

  130.         /// 

  131.         /// </summary>

  132.         private ConcurrentDictionary<int, Mat> defectPuaseImgList = new ConcurrentDictionary<int, Mat>();

  133. 

  134.         private object lock_defectDB = new object();

  135.         /// <summary>

  136.         /// 需要打标缺陷

  137.         /// </summary>

  138.         private List<DefectInfo> defectDBList = new List<DefectInfo>();

  139. 

  140. 

  141.         //实时速度

  142.         private double ActiveSpeed = 0;

  143.         //实时位置

  144.         private double ActiveDis = 0;

  145.         //图片队列     

  146.         private int listCntMax = 60;

  147.         private int Cam1Cnt = 0;

  148.         private int Cam2Cnt = 0;

  149. 

  150.         int _marginWidth1 = 0;

  151.         int _marginWidth2 = 0;

  152.         /// <summary>

  153.         /// 界面二次判定开启

  154.         /// </summary>

  155.         private bool DefectPauseForUser = true;

  156.         /// <summary>

  157.         /// 界面打标开启

  158.         /// </summary>

  159.         private bool DefectDBForUser = true;

  160.         /// <summary>

  161.         /// 第一次计米启用

  162.         /// </summary>

  163.         private bool JmFtStart = false;

  164.         /// <summary>

  165.         /// 界面光源值

  166.         /// </summary>

  167.         private int FrmLightValue = 0;

  168.         #region 处理类型

  169.         private class ScanPhotoInfo

  170.         {

  171.             /// <summary>

  172.             /// 

  173.             /// </summary>

  174.             /// <param name="_devIndex"></param>

  175.             /// <param name="_photoIndex">1-n 第1张会把1改为0</param>

  176.             /// <param name="_path"></param>

  177.             public ScanPhotoInfo(int _devIndex, int _photoIndex, string _path)

  178.             {

  179.                 devIndex = _devIndex;

  180.                 photoIndex = _photoIndex;

  181.                 path = _path;

  182.             }

  183.             public ScanPhotoInfo(int _devIndex, int _photoIndex, Mat _mat, double dis = 0)

  184.             {

  185.                 devIndex = _devIndex;

  186.                 photoIndex = _photoIndex;

  187.                 mat = _mat;

  188.                 CurrDis = dis;

  189.             }

  190.             public int devIndex { get; set; }

  191.             /// <summary>

  192.             /// 0-n 

  193.             /// </summary>

  194.             public int photoIndex { get; set; }

  195.             public string path { get; set; }

  196.             public Mat mat { get; set; }

  197. 

  198.             public double CurrDis { get; set; }

  199. 

  200.         }

  201.         #endregion

  202.         private ConcurrentQueue<ScanPhotoInfo> _matList1 = new ConcurrentQueue<ScanPhotoInfo>();

  203.         private ConcurrentQueue<ScanPhotoInfo> _matList2 = new ConcurrentQueue<ScanPhotoInfo>();

  204. 

  205.         private Service.ProductService PdtService = new Service.ProductService();

  206.         private Service.RecordsService RecordService = new Service.RecordsService();

  207. 

  208.         private bool _isOpenIO;

  209. 

  210.         private bool _isHaveImgL;

  211.         private bool _isHaveImgR;

  212.         #endregion

  213. 

  214.         #region 公开字段

  215.         private bool _isInit;

  216.         /// <summary>

  217.         /// 是否初始化完成

  218.         /// </summary>

  219.         public bool IsInit { get { return _isInit; } }

  220.         private bool _isRuning;

  221.         /// <summary>

  222.         /// 设备正在运行

  223.         /// </summary>

  224.         public bool IsRuning { get { return _isRuning; } }

  225. 

  226.         private bool _isAuto;

  227.         /// <summary>

  228.         /// 设备正在自动化流程中

  229.         /// </summary>

  230.         public bool IsAuto { get { return _isAuto; } }

  231.         #endregion

  232. 

  233.         #region 私有流程

  234.         //主流程

  235.         private Thread _mainThread;

  236.         private Thread _Cam1Thread;

  237.         private Thread _Cam2Thread;

  238.         private Thread _SpeedThread;

  239.         private Thread _SaveImgThread;

  240.         private CancellationTokenSource _cts;

  241. 

  242.         private Form _FatherFrm;

  243.         private object _lockOpenCV = new object();

  244.         #endregion

  245. 

  246.         #region 云端

  247.         //局域网云端

  248.         private bool init_Cloud;

  249.         private CloudMgr cloudMgr;

  250.         private int DailyOutput;

  251.         #endregion

  252.         private SysMgr()

  253.         {

  254.             _isInit = false;

  255.             _isRuning = false;

  256.             _isAuto = false;

  257. 

  258.             statusMgr = StatusMgr.Instance;

  259.             confMgr = ConfMgr.Instance;

  260. 

  261.             userMgr = new UserMgr(statusMgr.MySqlIP);

  262. 

  263.             _cts = new CancellationTokenSource();

  264. 

  265.             init_Cloud = false;

  266.             cloudMgr = new CloudMgr();

  267.             DailyOutput = 0;

  268. 

  269.             Service.InitDB.ConnectionString = confMgr.DBConStr;

  270.             PdtService = new Service.ProductService();

  271.             RecordService = new Service.RecordsService();

  272.         }

  273. 

  274.         #region 本地云上传

  275.         /// <summary>

  276.         /// 上传当日产量

  277.         /// </summary>

  278.         private void SendDailyOutput()

  279.         {

  280.             //开启云端

  281.             if (init_Cloud)

  282.             {

  283.                 try

  284.                 {

  285.                     if (!cloudMgr.SendTopic("device/attributes", $"{{ \"DailyOutput\": \"{DailyOutput}\"}}"))

  286.                         Log("云端", $"上传失败", WarningEnum.Low);

  287.                 }

  288.                 catch (Exception e)

  289.                 {

  290.                     Log("云端", $"上传失败:{e.Message}", WarningEnum.Low);

  291.                 }

  292.             }

  293.         }

  294.         /// <summary>

  295.         /// 上传正常状态

  296.         /// </summary>

  297.         public void SendStatus()

  298.         {

  299.             //开启云端

  300.             if (init_Cloud)

  301.             {

  302.                 //上传报警状态和信息

  303.                 string statusStr = "正常";

  304.                 switch (StatusMgr.Status)

  305.                 {

  306.                     case SystemStsEnum.Manual:

  307.                         statusStr = "人工操作";

  308.                         break;

  309.                     case SystemStsEnum.Standby:

  310.                         statusStr = "正常待机";

  311.                         break;

  312.                     case SystemStsEnum.Initial:

  313.                         statusStr = "初始化";

  314.                         break;

  315.                     case SystemStsEnum.Auto:

  316.                         statusStr = "自动运行";

  317.                         break;

  318.                     case SystemStsEnum.Pause:

  319.                         statusStr = "自动暂停";

  320.                         break;

  321.                     case SystemStsEnum.SetParams:

  322.                         statusStr = "参数设置";

  323.                         break;

  324.                     case SystemStsEnum.Debug:

  325.                         statusStr = "调试";

  326.                         break;

  327.                     case SystemStsEnum.Warning:

  328.                         statusStr = "系统报警";

  329.                         break;

  330.                     case SystemStsEnum.Bootload:

  331.                         statusStr = "Bootload";

  332.                         break;

  333.                     default:

  334.                         statusStr = "未知";

  335.                         break;

  336.                 }

  337.                 try

  338.                 {

  339.                     if (!cloudMgr.SendTopic("device/attributes", $"{{\"status\": \"{statusStr}\",  \"alm\": \"无报警信息\", " +

  340.                     $"\"name\": \"{confMgr.SysConfigParams.CloudThisName}\", \"DailyOutput\": \"{DailyOutput}\"}}"))

  341.                         Log("云端", $"上传失败", WarningEnum.Low);

  342.                 }

  343.                 catch (Exception e)

  344.                 {

  345.                     Log("云端", $"上传失败:{e.Message}", WarningEnum.Low);

  346.                 }

  347.             }

  348.         }

  349.         #endregion

  350. 

  351.         #region 用户+登入+管理

  352.         /// <summary>

  353.         /// 登入

  354.         /// </summary>

  355.         /// <returns></returns>

  356.         public bool LoginSystem()

  357.         {

  358.             return userMgr.UserLoginDialog();

  359.         }

  360.         /// <summary>

  361.         /// 用户权限

  362.         /// </summary>

  363.         public void UserPermissiomMgr()

  364.         {

  365.             userMgr.RightManageDialog();

  366.         }

  367.         /// <summary>

  368.         /// 用户管理

  369.         /// </summary>

  370.         public void UserListMgr()

  371.         {

  372.             userMgr.UserManagerDialog();

  373.         }

  374.         #endregion

  375. 

  376.         #region 系统初始化&&运行

  377.         /// <summary>

  378.         /// 系统初始化

  379.         /// </summary>

  380.         /// <returns></returns>

  381.         public bool Initial()

  382.         {

  383.             try

  384.             {

  385.                 bool ret = false;

  386.                 string err = "";

  387.                 ret = confMgr.LoadSystemConfig();

  388.                 //根据llog路径，开始记录日志

  389.                 if (!Directory.Exists(confMgr.SysConfigParams.LogPath))

  390.                     throw new Exception("日志路径不存在");

  391.                 statusMgr.StartLog(confMgr.SysConfigParams.LogPath);

  392.                 InitLog("系统开始初始化...");

  393.                 //Thread.Sleep(200);

  394.                 int minWorker, minIOC;

  395.                 ThreadPool.GetMinThreads(out minWorker, out minIOC);

  396.                 bool trt = ThreadPool.SetMinThreads(25, minIOC);

  397. 

  398.                 // 加载系统配置

  399.                 InitLog("加载系统参数...");

  400.                 //ret = confMgr.LoadSystemConfig();

  401. 

  402.                 if (!ret)

  403.                 {

  404.                     throw new Exception("系统参数加载失败...");

  405.                 }

  406.                 InitLog("系统参数加载完成！");

  407.                 //根据llog路径，开始记录日志

  408.                 //if(!Directory.Exists(confMgr.SysConfigParams.LogPath))

  409.                 //    throw new Exception("日志路径不存在");

  410.                 //statusMgr.StartLog(confMgr.SysConfigParams.LogPath);

  411.                 statusMgr.GotoInitial();

  412.                 SendStatus();

  413.                 //Thread.Sleep(200);

  414. 

  415. 

  416.                 // 硬件初始化

  417.                 if (!InitAllDev())

  418.                 {

  419.                     throw new Exception("硬件初始化失败...");

  420.                 }

  421.                 InitLog("硬件初始化完成！");

  422. 

  423.                 // 加载硬件配置

  424.                 InitLog("加载硬件驱动参数...");

  425.                 if (!LoadDevConfig())

  426.                 {

  427.                     throw new Exception("加载硬件驱动参数失败...");

  428.                 }

  429.                 InitLog("加载硬件驱动参数完成！");

  430.                 //Thread.Sleep(200);

  431.                 // 处理运行

  432.                 InitLog("AI算法核心初始化...");

  433.                 defectLib = new DefectLib();

  434.                 if (!defectLib.start())

  435.                     throw new Exception("外观检测核心初始化失败...");

  436.                 InitLog("AI算法核心初始化完成！");

  437. 

  438.                 LedReady();

  439. 

  440.                 //初始化成功

  441.                 _isInit = true;

  442.                 statusMgr.GotoNormalStandby();

  443.                 SendStatus();

  444. 

  445.                 OnInitRuning(new InitEventArgs("系统初始化完成...", this.IsInit));

  446. 

  447.                 Run();

  448. 

  449.                 return ret;

  450.             }

  451.             catch (Exception ex)

  452.             {

  453.                 InitLog(ex.Message, "初始化", WarningEnum.High);

  454.                 InitLog("系统初始化失败！", "初始化", WarningEnum.High);

  455.                 //statusMgr.GotoWarning(MaiMuControl.Device.WarningEnum.High, "初始化", ex.Message);

  456.                 return false;

  457.             }

  458.         }

  459. 

  460.         /// <summary>

  461.         /// 初始化图像处理报警

  462.         /// </summary>

  463.         /// <returns></returns>

  464.         public bool InitDefectEvent()

  465.         {

  466.             if (defectLib != null)

  467.             {

  468.                 defectLib.WarningEvent = (warning, msg) =>

  469.                 {

  470.                     Log("缺陷检测", msg, warning);

  471.                 };

  472.                 return true;

  473.             }

  474.             return false;

  475.         }

  476. 

  477.         public bool InitCloudConnect()

  478.         {

  479.             if (confMgr.SysConfigParams.OpenCloud)

  480.             {

  481.                 if (cloudMgr.ConnectCloud(confMgr.SysConfigParams.CloudServerIP, confMgr.SysConfigParams.CloudServerPort,

  482.                     confMgr.SysConfigParams.CloudUser, confMgr.SysConfigParams.CloudPassword))

  483.                 {

  484.                     init_Cloud = true;

  485.                     Log("云端数据", "开启云端连接");

  486.                     return true;

  487.                 }

  488.                 Log("云端数据", "云端连接失败！", WarningEnum.Low);

  489.                 return false;

  490.             }

  491.             return true;

  492.         }

  493.         /// <summary>

  494.         /// 运行主线程

  495.         /// </summary>

  496.         private void Run()

  497.         {

  498.             _mainThread = new Thread(() =>

  499.             {

  500.                 MainThreadFunction();

  501.             });

  502.             _mainThread.IsBackground = true;

  503.             _mainThread.Start();

  504. 

  505. #if Online_One

  506. #else

  507.             _Cam1Thread = new Thread(() =>

  508.             {

  509.                 Cam1ThreadFunction();

  510.             });

  511.             _Cam1Thread.IsBackground = true;

  512.             _Cam1Thread.Start();

  513. 

  514.             _Cam2Thread = new Thread(() =>

  515.             {

  516.                 Cam2ThreadFunction();

  517.             });

  518.             _Cam2Thread.IsBackground = true;

  519.             _Cam2Thread.Start();

  520. #endif

  521.             _SpeedThread = new Thread(() =>

  522.             {

  523.                 GetLenAndSpd();

  524.             });

  525.             _SpeedThread.IsBackground = true;

  526.             _SpeedThread.Start();

  527. 

  528.             _SaveImgThread = new Thread(() =>

  529.             {

  530.                 SaveImgThreadFunction();

  531.             });

  532.             _SaveImgThread.IsBackground = true;

  533.             _SaveImgThread.Start();

  534.         }

  535.         #endregion

  536. 

  537.         #region 二次判断开关

  538.         public void SetDefectPause(bool val)

  539.         {

  540.             DefectPauseForUser = val;

  541.         }

  542. 

  543.         public bool GetDefectPause()

  544.         {

  545.             return DefectPauseForUser;

  546.         }

  547.         #endregion

  548. 

  549.         #region 打标开关

  550.         public void SetDefectDB(bool val)

  551.         {

  552.             DefectDBForUser = val;

  553.         }

  554. 

  555.         public bool GetDefectDB()

  556.         {

  557.             return DefectDBForUser;

  558.         }

  559.         #endregion

  560. 

  561.         #region 界面光源设置

  562.         public void SetLightValue(int val)

  563.         {

  564.             FrmLightValue = val;

  565.             if(IsInit)

  566.                 lightDev.SetLightDigitalValue(1, val);

  567.         }

  568.         #endregion

  569. 

  570.         #region 计米器控制

  571.         /// <summary>

  572.         /// 计米器清空

  573.         /// </summary>

  574.         private void ClearLengthCount()

  575.         {

  576.             if (confMgr.SysConfigParams.OpenLengthCount)

  577.             {

  578.                 byte[] clearData = new byte[] { 0x01, 0x06, 0x00, 0x00, 0x00, 0x01, 0x48, 0x0a };

  579.                 lengthCounter.Write(clearData, 0, 8);

  580.                 //Thread.Sleep(100);

  581.                 Thread.Sleep(10);

  582.                 byte[] recv = new byte[64];

  583.                 //string recvdata = serialPort.ReadLine();

  584.                 //recv = recvdata.ToBytes();

  585.                 int readCnt = lengthCounter.BytesToRead;

  586.                 lengthCounter.Read(recv, 0, readCnt);

  587.             }

  588.         }

  589. 

  590.         /// <summary>

  591.         /// 获取计米数据

  592.         /// </summary>

  593.         /// <returns></returns>

  594.         private double GetLength()

  595.         {

  596.             //bool isFile = true;

  597.             double length = -1;

  598.             bool GetData = false;

  599.             if (lengthCounter.IsOpen)

  600.             {

  601.                 byte[] data = new byte[] { 0x01, 0x03, 0x00, 0x21, 0x00, 0x02, 0x94, 0x01 };

  602.                 lengthCounter.Write(data, 0, 8);

  603.                 Thread.Sleep(10);

  604.                 byte[] recv = new byte[64];

  605.                 //string recvdata = serialPort.ReadLine();

  606.                 //recv = recvdata.ToBytes();

  607.                 int readCnt = lengthCounter.BytesToRead;

  608.                 lengthCounter.Read(recv, 0, readCnt);

  609.                 byte[] bytes = new byte[4];

  610.                 for (int i = 0; i < readCnt; i++)

  611.                 {

  612.                     if (recv[i] == 0x01 && recv[i + 1] == 0x03 && recv[i + 2] == 0x04)

  613.                     {

  614.                         bytes[0] = recv[i + 3];

  615.                         bytes[1] = recv[i + 4];

  616.                         bytes[2] = recv[i + 5];

  617.                         bytes[3] = recv[i + 6];

  618.                         GetData = true;

  619.                     }

  620.                 }

  621.                 if (GetData)

  622.                 {

  623.                     if (BitConverter.IsLittleEndian)

  624.                         Array.Reverse(bytes);

  625.                     int spddata = BitConverter.ToInt32(bytes, 0);

  626.                     length = spddata / 100.0;

  627. 

  628.                     //if (isFile)

  629.                     //    length = -length;

  630.                 }

  631.                 if (length > 10000)

  632.                     return -1;

  633.             }

  634.             return length;

  635.         }

  636.         #endregion

  637. 

  638.         #region 后台

  639. 

  640.         #region 计米器位置和速度

  641.         private object LockSpd = new object();

  642.         private object LockDis = new object();

  643.         private void SetSpd(double spd)

  644.         {

  645.             lock (LockSpd)

  646.             {

  647.                 ActiveSpeed = spd;

  648.             }

  649.         }

  650.         private double GetSpd()

  651.         {

  652.             double spd;

  653.             lock (LockSpd)

  654.             {

  655.                 spd = ActiveSpeed;

  656.             }

  657.             return spd;

  658.         }

  659.         private void SetDis(double dis)

  660.         {

  661.             lock (LockDis)

  662.             {

  663.                 ActiveDis = dis;

  664.             }

  665.         }

  666.         private double GetDis()

  667.         {

  668.             double dis;

  669.             lock (LockDis)

  670.             {

  671.                 dis = ActiveDis;

  672.             }

  673.             return dis;

  674.         }

  675.         #endregion

  676. 

  677.         #region 中断

  678.         /// <summary>

  679.         /// 中断工序运行

  680.         /// </summary>

  681.         /// <returns></returns>

  682.         private bool isBreakProcessRun()

  683.         {

  684.             return statusMgr.Status == SystemStsEnum.Pause || statusMgr.Warning == WarningEnum.High;

  685.         }

  686.         #endregion

  687. 

  688.         #region 长度与速度流程

  689.         /// <summary>

  690.         /// 获取速度和长度

  691.         /// </summary>

  692.         private void GetLenAndSpd()

  693.         {

  694.             double stl = 0; //计米起始位置

  695.             double etl = 0; //计米结束位置

  696.             double spl = 0; //计算速度计米位置

  697.             double yqjimi = 0; //计米长度

  698.             double cehouDis = 0;//测厚位置记录

  699.             double UseTime = 1;

  700.             double preSpd = 0;//上次速度，防止速度出差

  701.             double rioSpd = 0.3;//过冲

  702.             while (true)

  703.             {

  704.                 int spdcnt = 0;

  705.                 try

  706.                 {

  707.                     if (_cts.IsCancellationRequested)

  708.                         break;

  709. 

  710.                     if (IsRuning)

  711.                     {

  712.                         ////暂停开始

  713.                         //stopWatch.Start();

  714.                         do

  715.                         {

  716. #if Online

  717.                             if (currKey > 0)

  718.                             {

  719.                                 Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  720.                                 #region 实时速度

  721. 

  722.                                 if (confMgr.SysConfigParams.OpenLengthCount)

  723.                                 {

  724.                                     double length = GetLength();

  725.                                     if (length >= 0)

  726.                                     {

  727.                                         

  728.                                         if (!JmFtStart)

  729.                                         {

  730.                                             //第一次记录起始数据

  731.                                             stl = 0;

  732.                                             spl = 0;

  733.                                             cehouDis = 0;

  734.                                             JmFtStart = true;

  735.                                             pRunSpeedWatch.Restart();

  736.                                         }

  737.                                         else

  738.                                         {

  739.                                             //1s计算一次实时速度

  740.                                             double dt = pRunSpeedWatch.ElapsedMilliseconds;

  741.                                             if (dt / 1000.0d > UseTime)

  742.                                             {

  743.                                                 double spddis = Math.Abs(length - spl);

  744.                                                 spl = length;

  745. 

  746.                                                 double runOnePicTime = dt / 1000.0d /( 60.0d);//总时间 分

  747.                                                 double spd = Math.Round(spddis / runOnePicTime, 2);

  748.                                                 //if (spd !=0&&((Math.Abs(spd - preSpd) / preSpd) > rioSpd))

  749.                                                 //{

  750.                                                 //    spd = (Math.Abs(spd - preSpd))/4 + preSpd;

  751.                                                 //}

  752.                                                 

  753.                                                 preSpd = spd;

  754.                                                 SetSpd(spd);

  755. 

  756.                                                 if (spdcnt > 2)

  757.                                                 {

  758.                                                     Log($"计米对比", $"计米器距离{Math.Round(spddis,2)},计米速度{Math.Round(spd,2)},计米时间{Math.Round(runOnePicTime,4)}", WarningEnum.Normal, false);

  759.                                                     spdcnt = 0;

  760.                                                 }

  761.                                                 spdcnt++;

  762.                                                 //重新计时

  763.                                                 pRunSpeedWatch.Restart();

  764.                                             }

  765.                                             etl = length;//记录当前读数

  766.                                             yqjimi = Math.Round((etl - stl) / 1.00, 2); //记录长度

  767.                                             SetDis(yqjimi);

  768.                                         }

  769.                                         lock (lockCurrKey)

  770.                                         {

  771.                                             curRecord.Len = yqjimi;

  772.                                             curRecord.TimeLen = pStopWatch.ElapsedMilliseconds / 1000.0d / 60.0d;//总时间 分

  773.                                         }

  774.                                         double tRunSpd = GetSpd();//1s计算的实时速度

  775.                                                                   //显示平均速度

  776.                                         OnAutoRuning(new RunEventArgs(yqjimi, tRunSpd));

  777. 

  778.                                         #region 处理2次判定

  779. 

  780. 

  781.                                         //处理2次判定

  782.                                         double aveSpd = Math.Round(yqjimi / (pStopWatch.ElapsedMilliseconds / 1000.0d / (60.0d)), 2);

  783.                                         double StopDecRunDis = tRunSpd / 60.0 * confMgr.SysConfigParams.StopDecTime / 2;

  784.                                         double atcDis = (confMgr.SysConfigParams.StopLookDis - StopDecRunDis);

  785. 

  786.                                         //计米器判断暂停:瑕疵二次判断 存在问题

  787.                                         if (confMgr.SysConfigParams.OpenLengthCountStop && DefectPauseForUser && defectPuaseList.Count > 0)

  788.                                         {

  789.                                             if ((yqjimi - atcDis) > (defectPuaseList[0].Y / 100))

  790.                                             {

  791.                                                 //if ((yqjimi - atcDis) < (defectPuaseList[0].Y / 100 + 1))

  792.                                                 {

  793.                                                     Log($"二次判断", $"计米器{yqjimi},瑕疵位置{defectPuaseList[0].Y / 100},停车距离{confMgr.SysConfigParams.StopLookDis}m,停车减速时间{confMgr.SysConfigParams.StopDecTime}s,减速位移{StopDecRunDis},实际停车距离{atcDis},实时速度{tRunSpd},匀速{aveSpd}", WarningEnum.Normal, false);

  794.                                                     List<DefectInfo> lstEditDefect0 = defectPuaseList.Where(m => m.PhotoIndex == defectPuaseList[0].PhotoIndex).ToList();

  795.                                                     Log($"二次判断", $"(图像{defectPuaseList[0].PhotoIndex})已达观察台，瑕疵二次判断=》({string.Join(",", lstEditDefect0.Select(m => m.Code).ToArray())})是否包含在({string.Join(",", curRecord.ProductInfo.DefectPauseOption.ToArray())})中。", WarningEnum.Normal, false);

  796.                                                     //瑕疵选项过滤

  797.                                                     if (curRecord.ProductInfo.DefectPauseOption.Count == 0 || lstEditDefect0.Where(x => curRecord.ProductInfo.DefectPauseOption.Contains(x.Code)).Count() > 0)

  798.                                                     {

  799.                                                         Log($"二次判断", $"(图像{defectPuaseList[0].PhotoIndex})需瑕疵二次判断，已达观察台，进入暂停。", WarningEnum.Normal, false);

  800.                                                         if (lstEditDefect0.Where(x => DefectItemsPuaseNameList.Contains(x.Name)).Count() > 0)

  801.                                                         {   

  802.                                                             Stop();

  803.                                                             //获取完整数据

  804.                                                             Thread.Sleep(500);

  805.                                                             var lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == defectPuaseList[0].PhotoIndex).ToList();

  806.                                                             #region 二级界面

  807.                                                             int liPhotoIndex = defectPuaseList[0].PhotoIndex;

  808.                                                             #region 加载界面

  809.                                                             if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  810.                                                             {

  811.                                                                 var pimage = (Bitmap)defectPuaseImgList[liPhotoIndex].ToBitmap().Clone();

  812.                                                                 var pmat = defectPuaseImgList[liPhotoIndex].Clone();

  813.                                                                 Task.Run(() =>

  814.                                                                 {

  815.                                                                     int liDefectCount = lstEditDefect.Count;

  816.                                                                     ImageShowFrm frmDefect = new ImageShowFrm(liPhotoIndex, lstEditDefect, pimage);

  817.                                                                     //frmDefect.Show();

  818.                                                                     if (frmDefect.ShowDialog() == DialogResult.OK)

  819.                                                                     {

  820. 

  821.                                                                         SysMgr.Instance.DelDefectEdit(curRecord, frmDefect.lstDel);

  822. 

  823.                                                                         OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat, frmDefect.lstDel));

  824.                                                                         //double len = (double)this.lblLen.Tag;

  825.                                                                         //this.reDrawDefectPoints(curRecord.DefectInfoList, new double[] { 0, Math.Round(curRecord.FaceWidthMax + 0.005f, 2) }, new double[] { 0, len });

  826.                                                                         Log($"二次检测", $"本次忽略{frmDefect.lstDel.Count}个瑕疵，本张图由{liDefectCount} -> {lstEditDefect.Count}，总数{curRecord.DefectInfoList.Count}");

  827.                                                                     }

  828.                                                                     else

  829.                                                                     {

  830.                                                                         OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat, null));

  831.                                                                     }

  832.                                                                 });

  833.                                                             }

  834.                                                             else

  835.                                                                 Log($"二次检测", $"本次图像已检测完成");

  836.                                                             #endregion

  837.                                                             //OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, defectPuaseImgList[liPhotoIndex]));

  838.                                                             #endregion

  839.                                                         }

  840.                                                     }

  841. 

  842.                                                     Log($"二次判断删除", $"{defectPuaseList[0].PhotoIndex}-{testCnt}", WarningEnum.Normal, false);

  843.                                                     

  844.                                                     lstEditDefect0 = defectPuaseList.Where(m => m.PhotoIndex == defectPuaseList[0].PhotoIndex).ToList();

  845.                                                     if (lstEditDefect0.Count > 0 && defectPuaseImgList.Count > 0)

  846.                                                     {

  847.                                                         Mat mt;

  848.                                                         defectPuaseImgList.TryRemove(lstEditDefect0[0].PhotoIndex, out mt);

  849.                                                     }

  850.                                                     //foreach (var item in lstEditDefect0)

  851.                                                     {

  852.                                                         lock (lock_defectPuase)

  853.                                                         {

  854.                                                             defectPuaseList.RemoveAll(m => m.PhotoIndex == defectPuaseList[0].PhotoIndex);

  855.                                                             //defectPuaseList.Remove(item);

  856.                                                         }

  857.                                                     }

  858.                                                     

  859.                                                 }

  860.                                                 //else

  861.                                                 //{

  862.                                                 //    Log($"二次判断", $"速度过快，超过展示位置！实时速度{tRunSpd}，{defectPuaseList[0].PhotoIndex}-{testCnt}", WarningEnum.Low, true);

  863.                                                 //}

  864.                                             }

  865.                          

  866.                                         }

  867.                                         

  868.                                         //计米器判定打标

  869.                                         if(DefectDBForUser && defectDBList.Count >0)

  870.                                         {

  871.                                             //判断是否开启打标

  872.                                             if((yqjimi - defectDBList[0].CurrDis + (defectDBList[0].PicY / 100)  - confMgr.SysConfigParams.CamToDBDis) >= 0)

  873.                                             {

  874.                                                 Log($"打标", $"计米器{yqjimi},瑕疵位置{defectDBList[0].PicY / 100},拍照位置{defectDBList[0].CurrDis},打标机距离{confMgr.SysConfigParams.StopLookDis}m,", WarningEnum.Normal, false);

  875.                                                 StartDB();

  876.                                                 Log($"打标判断删除", $"{defectDBList[0].PhotoIndex}-{defectDBList[0].Name}", WarningEnum.Normal, false);

  877.                                                 defectDBList.RemoveAt(0);

  878.                                             }

  879.                                         }

  880.                                         #endregion

  881.                                     }

  882.                                 }

  883. 

  884.                                 #endregion

  885. #endif

  886.                             #region 堆积显示

  887.                             OnAutoRuning(new RunEventArgs(_matList1.Count, _matList2.Count, defectLib.GetDefectInfo()));

  888. 

  889. 

  890.                                 //System.GC.Collect();

  891.                                 #endregion

  892. 

  893. #if Online

  894.                             lock (lockCurrKey)

  895.                                 {

  896.                                     #region 换卷长度提示

  897.                                     if (confMgr.SysConfigParams.OpenLengthCount)

  898.                                     {

  899.                                         if (curRecord.ProductInfo.residueWarnningLen > 0 && yqjimi > curRecord.ProductInfo.residueWarnningLen)

  900.                                         {

  901.                                             Log($"告警", $"已经达到换卷长度最大值{curRecord.ProductInfo.residueWarnningLen}-当前长度{yqjimi}-", WarningEnum.High);

  902.                                         }

  903.                                     }

  904.                                     #endregion

  905. 

  906.                                     #region 测厚停止

  907.                                     if (confMgr.SysConfigParams.OpenLengthCount && curRecord.ProductInfo.OpenThicknessDetection)

  908.                                     {

  909.                                         if (curRecord.ProductInfo.ThicknessDetectionStopDis > 0 && (yqjimi - cehouDis) > curRecord.ProductInfo.ThicknessDetectionStopDis)

  910.                                         {

  911.                                             Stop();

  912.                                             Log($"测厚提示", $"已经达到测厚位置{curRecord.ProductInfo.ThicknessDetectionStopDis}-当前前进长度{(yqjimi - cehouDis)}-", WarningEnum.High);

  913.                                         }

  914.                                     }

  915.                                     #endregion

  916.                                 }

  917.                             }

  918. #endif

  919.                             Thread.Sleep(200);

  920.                         } while (!isBreakProcessRun());

  921.                         //暂停中断

  922.                         //stopWatch.Stop();

  923.                         //pStopWatch.Stop();

  924.                         //_isRuning = false;

  925.                     }

  926.                     Thread.Sleep(10);

  927.                 }

  928.                 catch (Exception e)

  929.                 {

  930.                     _isRuning = false;

  931. 

  932.                     Log("运行报警", "计米流程运行出错：" + e.Message + "\n", WarningEnum.High);

  933.                 }

  934.             }

  935.         }

  936.         #endregion

  937. 

  938.         #region 相机线程1 && 二次判定

  939.         /// <summary>

  940.         /// 相机1采图预处理

  941.         /// </summary>

  942.         private void Cam1ThreadFunction()

  943.         {

  944.             int errStep = 0;

  945. #if Online

  946. #else

  947.             string imgfilePath = "D:\\CPL\\img\\L1.bmp";

  948.             Mat timg = new Mat(imgfilePath);

  949.             timg = timg.Flip(FlipMode.XY);

  950. #endif

  951.             while (true)

  952.             {

  953.                 try

  954.                 {

  955.                     if (_cts.IsCancellationRequested)

  956.                         break;

  957. 

  958.                     if (IsRuning)

  959.                     {

  960.                         ////暂停开始

  961.                         //stopWatch.Start();

  962.                         do

  963.                         {

  964.                             #region 实时采图

  965. #if Online

  966.                             //采集图片

  967.                             AcquisitionMat acq = _LinecamDev1.GetFrames(100);

  968.                             if (acq.GrabStatus == "GrabPass")

  969.                             {

  970. #else

  971.                             Thread.Sleep(2500);

  972.                             AcquisitionMat acq = new AcquisitionMat();

  973.                             {

  974.                                 acq.GrabStatus = "GrabPass";

  975.                                 acq.Image = timg.Clone();

  976.                                 Log($"图像预处理", $"模拟相机1-{Cam1Cnt}", WarningEnum.Normal, true);

  977.                             }

  978.                             

  979.                             if (acq.GrabStatus == "GrabPass")

  980.                             { 

  981. #endif

  982. 

  983.                                 //专用二次判断处理

  984. #if true

  985.                                 #region 处理2次判定

  986.                                 if (!confMgr.SysConfigParams.OpenLengthCountStop)

  987.                                 {

  988.                                     //处理2次判定

  989.                                     //暂停:瑕疵二次判断

  990.                                     if (DefectPauseForUser )

  991.                                     {

  992.                                         errStep = 11;

  993.                                         Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  994.                                         int liPhotoIndex = Cam1Cnt - confMgr.SysConfigParams.StopImageCnt;

  995. #if false

  996.                                         var havePause = curRecord.dicPhoto_Defect.Where(x => x.Key <= liPhotoIndex && x.Value == true);

  997.                                         if(havePause != null)

  998.                                         {

  999.                                             foreach (var item in havePause)

  1000.                                             {

  1001.                                                 liPhotoIndex = item.Key;

  1002.                                                 break;

  1003.                                             }

  1004.                                             

  1005.                                         }

  1006. #endif

  1007.                                         //Log($"二次判断2", $"图像{scanPhotos0.photoIndex}  {liPhotoIndex}={scanPhotos0.photoIndex}-{confMgr.SysConfigParams.StopImageCnt}；{JsonConvert.SerializeObject(curRecord.dicPhoto_Defect)}", WarningEnum.Normal, false);

  1008.                                         if (liPhotoIndex >= 0 && curRecord.dicPhoto_Defect.ContainsKey(liPhotoIndex) && curRecord.dicPhoto_Defect[liPhotoIndex] )

  1009.                                         {

  1010.                                             if (defectPuaseList.Count > 0)

  1011.                                             { 

  1012.                                                 errStep = 12;

  1013.                                                 List<DefectInfo> lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1014.                                                 Log($"二次判断2", $"(图像{liPhotoIndex})已达观察台，瑕疵二次判断=》({string.Join(",", lstEditDefect.Select(m => m.Code).ToArray())})是否包含在({string.Join(",", curRecord.ProductInfo.DefectPauseOption.ToArray())})中。", WarningEnum.Normal, false);

  1015.                                                 //瑕疵选项过滤

  1016.                                                 if (curRecord.ProductInfo.DefectPauseOption.Count == 0 || lstEditDefect.Where(x => curRecord.ProductInfo.DefectPauseOption.Contains(x.Code)).Count() > 0)

  1017.                                                 {

  1018.                                                     Log($"二次判断2", $"(图像{liPhotoIndex})需瑕疵二次判断，已达观察台，进入暂停。速度:{GetSpd()}");

  1019.                                                     // if (lstEditDefect.Where(x => x.Code == "jietou").Count() > 0)

  1020.                                                     if (lstEditDefect.Where(x => DefectItemsPuaseNameList.Contains(x.Name)).Count() > 0)

  1021.                                                     {

  1022.                                                         Stop();

  1023.                                                         //获取完整数据

  1024.                                                         Thread.Sleep(500);

  1025. 

  1026.                                                         lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1027.                                                         //获取完整数据

  1028.                                                         #region 二级界面

  1029.                                                         #region 加载界面

  1030.                                                         if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  1031.                                                         {

  1032.                                                             var pmat = defectPuaseImgList[liPhotoIndex].Clone();

  1033.                                                             //OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat));

  1034. #if true

  1035.                                                             var pimage = (Bitmap)defectPuaseImgList[liPhotoIndex].ToBitmap().Clone();

  1036.                                                             Task.Run(() =>

  1037.                                                             {

  1038.                                                                 int liDefectCount = lstEditDefect.Count;

  1039.                                                                 ImageShowFrm frmDefect = new ImageShowFrm(liPhotoIndex, lstEditDefect, pimage);

  1040.                                                                 //if (frmDefect.ShowDialog(_FatherFrm) == DialogResult.OK)

  1041.                                                                 if (frmDefect.ShowDialog() == DialogResult.OK)

  1042.                                                                 {

  1043.                                                                     SysMgr.Instance.DelDefectEdit(curRecord, frmDefect.lstDel);

  1044.                                                                     OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat, frmDefect.lstDel));

  1045.                                                                     Log($"二次检测2", $"本次忽略{frmDefect.lstDel.Count}个瑕疵，本张图由{liDefectCount} -> {lstEditDefect.Count}，总数{curRecord.DefectInfoList.Count}");

  1046.                                                                 }

  1047.                                                                 else

  1048.                                                                 {

  1049.                                                                     OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat, null));

  1050.                                                                 }

  1051.                                                             });

  1052. #endif

  1053.                                                         }

  1054.                                                         else

  1055.                                                             Log($"二次检测2", $"本次图像已检测完成");

  1056. #endregion

  1057.                                                         //OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, defectPuaseImgList[liPhotoIndex]));

  1058. #endregion

  1059.                                                         

  1060.                                                     }

  1061.                                                     errStep = 18;

  1062. 

  1063.                                                 }

  1064.                                                 Log($"二次判断删除", $"{liPhotoIndex}-{testCnt}", WarningEnum.Normal, false);

  1065.                                                 

  1066.                                                 lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1067.                                                 

  1068.                                                 if (lstEditDefect.Count > 0 && defectPuaseImgList.Count > 0)

  1069.                                                 {

  1070.                                                     Mat mt;

  1071.                                                     defectPuaseImgList.TryRemove(lstEditDefect[0].PhotoIndex, out mt);

  1072.                                                 }

  1073.                                                 //foreach (var item in lstEditDefect)

  1074.                                                 {

  1075.                                                     lock (lock_defectPuase)

  1076.                                                     {

  1077.                                                         defectPuaseList.RemoveAll(m => m.PhotoIndex == liPhotoIndex);

  1078.                                                         //defectPuaseList.Remove(item);

  1079.                                                     }

  1080.                                                 }

  1081.                                                 

  1082.                                             }

  1083.                                             else

  1084.                                                 Log($"二次判断2", $"(图像{liPhotoIndex})-缺陷未获得", WarningEnum.Low, false);

  1085. #if false

  1086.                                             curRecord.dicPhoto_Defect.TryUpdate(liPhotoIndex, false, true);

  1087. #endif

  1088.                                         }

  1089.                                         //else

  1090.                                         //    Log($"二次判断2", $"(图像{liPhotoIndex})-处理未跟上", WarningEnum.Low, false);

  1091.                                     }

  1092.                                     //time += $"->处理2次判定({stopWatch.ElapsedMilliseconds})";

  1093.                                 }

  1094. #endregion

  1095. #endif

  1096. 

  1097.                                             //预处理

  1098.                                             Stopwatch stopWatch = new Stopwatch();

  1099.                                 //Log($"图像预处理", $"相机1-{Cam1Cnt}", WarningEnum.Normal, false);

  1100.                                 string time = "";

  1101.                                 stopWatch.Start();

  1102.                                 Mat img = acq.Image.Clone();

  1103.                                 //图像镜像

  1104.                                 if (confMgr.SysConfigParams.Cam1_flipX && confMgr.SysConfigParams.Cam1_flipY)

  1105.                                 {

  1106.                                     img = img.Flip(FlipMode.XY);

  1107.                                     //Cv2.Flip(img, img, FlipMode.XY);//翻转

  1108.                                 }

  1109.                                 else if (confMgr.SysConfigParams.Cam1_flipX)

  1110.                                 {

  1111.                                     img = img.Flip(FlipMode.X);

  1112.                                     //Cv2.Flip(img, img, FlipMode.X);//翻转

  1113.                                 }

  1114.                                 else if (confMgr.SysConfigParams.Cam1_flipY)

  1115.                                 {

  1116.                                     img = img.Flip(FlipMode.Y);

  1117.                                     //Cv2.Flip(img, img, FlipMode.Y);//翻转 

  1118.                                 }

  1119.                                 time += $"->相机1翻转({stopWatch.ElapsedMilliseconds})";

  1120.                                 //显示

  1121.                                 //OnAutoRuning(new RunEventArgs(1, img));

  1122. 

  1123.                                 //lock (_lockOpenCV)

  1124.                                 {

  1125.                                     //存在数据队列

  1126.                                     if (currKey != 0 || htTask.ContainsKey(currKey))

  1127.                                     {

  1128.                                         //保存图片

  1129.                                         if (confMgr.SysConfigParams.CamImag.AutoSave && !string.IsNullOrEmpty(confMgr.SysConfigParams.CamImag.SavePath))

  1130.                                         {

  1131.                                             Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  1132.                                             string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.CamImag.SavePath, new List<string> { $"{curRecord.BarCode}_{curRecord.BarCodeName}" });

  1133.                                             //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(img).Save($"{dirPath}Cam1-{Cam1Cnt}.bmp", ImageFormat.Bmp);

  1134. 

  1135.                                             AddImageSave($"{dirPath}Cam1-{Cam1Cnt}.bmp", img);

  1136.                                         }

  1137.                                         if (_matList1.Count > listCntMax)

  1138.                                         {

  1139.                                             Log($"堆积过多", $"相机1-缓存{_matList1.Count}大于{listCntMax}", WarningEnum.High);

  1140.                                             //_matList1.Dequeue();

  1141.                                             System.GC.Collect();

  1142.                                         }

  1143.                                         

  1144.                                         

  1145.                                         Mat mat = img;

  1146.                                         try

  1147.                                         {

  1148.                                             errStep = 1;

  1149. 

  1150.                                             //反转+相机索引调换

  1151.                                             //lock (_lockOpenCV)

  1152.                                             {

  1153.                                                 //裁边，两侧和中间重合部分 

  1154.                                                 if (confMgr.SysConfigParams.MidCoin > 0)//中间重合部分

  1155.                                                 {

  1156.                                                     errStep = 3;

  1157.                                                     int width = mat.Width - confMgr.SysConfigParams.MidCoin / 2;

  1158.                                                     mat = OpencvUtils.CutImage(mat, 0, 0, width, mat.Height);

  1159.                                                     time += $"->相机1-去重({stopWatch.ElapsedMilliseconds})";

  1160.                                                 }

  1161.                                             }

  1162.                                             errStep = 4;

  1163.                                             //左裁边

  1164.                                             int marginWidth0;

  1165.                                             mat = OpencvUtils.getMaxInsetRect2(mat, true, confMgr.SysConfigParams.HolePx, out marginWidth0);

  1166.                                             //存储裁边异常相机图 差异5cm

  1167.                                             if (_marginWidth1 == 0)

  1168.                                                 _marginWidth1 = marginWidth0;

  1169. 

  1170.                                             if (!confMgr.SysConfigParams.CamImag.AutoSave && Math.Abs(marginWidth0 - _marginWidth1) > (10 * confMgr.SysConfigParams.Cm2px_x) && !string.IsNullOrEmpty(confMgr.SysConfigParams.CamImag.SavePath))

  1171.                                             {

  1172.                                                 Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  1173.                                                 string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.CamImag.SavePath, new List<string> { $"{curRecord.BarCode}_{curRecord.BarCodeName}" });

  1174.                                                 AddImageSave($"{dirPath}Cam1-{Cam1Cnt}.bmp", img);

  1175.                                                 Log($"图像预处理", $"(相机1-图像{Cam1Cnt})-裁边异常：{marginWidth0}-{_marginWidth1} 》 {10 * confMgr.SysConfigParams.Cm2px_x}", WarningEnum.Normal, false);

  1176.                                             }

  1177.                                             _marginWidth1 = marginWidth0;

  1178.                                             errStep = 5;

  1179.                                             time += $"->相机1裁边({stopWatch.ElapsedMilliseconds})";

  1180.                                             Log($"图像预处理", $"(相机1-图像{Cam1Cnt})-左图去重后：{mat.Width}*{mat.Height}，" + $"重复值：{confMgr.SysConfigParams.MidCoin / 2} + 时间{time}", WarningEnum.Normal, false);

  1181.                                             //System.GC.Collect();

  1182.                                         }

  1183.                                         catch (Exception e)

  1184.                                         {

  1185.                                             Log($"图像处理", $"异常({errStep})：(相机1-图像{Cam1Cnt})-{e.Message}", WarningEnum.High);

  1186.                                         }

  1187.                                         //Log($"图像1入队列", $"相机1-{Cam1Cnt}", WarningEnum.Normal, false);

  1188.                                         //Cv2.Flip(img, img, FlipMode.XY);//翻转

  1189.                                         _matList1.Enqueue(new ScanPhotoInfo(0, Cam1Cnt++, mat.Clone()));

  1190.                                     }

  1191.                                     else

  1192.                                         Log($"相机1", $"(图像)-未扫码，图像丢弃！", WarningEnum.Low);

  1193.                                 }                             

  1194.                             }

  1195.                       

  1196.                             #endregion

  1197.                             //System.GC.Collect();

  1198.                             Thread.Sleep(50);

  1199.                         } while (!isBreakProcessRun());

  1200.                         //暂停中断

  1201.                         //stopWatch.Stop();

  1202.                         pStopWatch.Stop();

  1203.                         //_isRuning = false;

  1204.                     }

  1205.                     else

  1206.                     {

  1207.                         //防止内存爆满

  1208.                         AcquisitionMat acq = _LinecamDev1.GetFrames(10);

  1209.                     }

  1210.                     Thread.Sleep(50);

  1211.                 }

  1212.                 catch (Exception e)

  1213.                 {

  1214.                     _isRuning = false;

  1215. 

  1216.                     Log("运行报警", $"相机1流程运行出错{errStep}：" + e.Message + "\n", WarningEnum.High);

  1217.                 }

  1218.             }

  1219.         }

  1220.         #endregion

  1221. 

  1222.         #region 相机线程2 && 图片位置

  1223.         /// <summary>

  1224.         /// 相机2采图预处理

  1225.         /// </summary>

  1226.         private void Cam2ThreadFunction()

  1227.         {      

  1228. #if Online

  1229. #else

  1230.             string imgfilePath = "D:\\CPL\\img\\R1.bmp";

  1231.             Mat timg = new Mat(imgfilePath);

  1232.             timg = timg.Flip(FlipMode.XY);

  1233. #endif

  1234.             while (true)

  1235.             {

  1236.                 try

  1237.                 {

  1238.                     if (_cts.IsCancellationRequested)

  1239.                         break;

  1240. 

  1241.                     if (IsRuning)

  1242.                     {

  1243.                         ////暂停开始

  1244.                         //stopWatch.Start();

  1245.                         do

  1246.                         {

  1247.                             #region 实时采图

  1248. #if Online

  1249.                             //采集图片

  1250.                             AcquisitionMat acq = _LinecamDev2.GetFrames(10);

  1251.                             if (acq.GrabStatus == "GrabPass")

  1252.                             {

  1253. #else

  1254.                             Thread.Sleep(2500);

  1255.                             AcquisitionMat acq = new AcquisitionMat();

  1256.                             {

  1257.                                 acq.GrabStatus = "GrabPass";

  1258.                                 acq.Image = timg;

  1259.                                 Log($"图像预处理", $"模拟相机2-{Cam2Cnt}", WarningEnum.Normal, true);

  1260.                             }

  1261. 

  1262.                             if (acq.GrabStatus == "GrabPass")

  1263.                             {

  1264. #endif

  1265.                                 //获取图片成功，说明正好拍完照片，获取当前计米器位置

  1266.                                 double picDis = GetDis();

  1267. 

  1268.                                 Mat img = acq.Image.Clone();

  1269.                                 //预处理

  1270.                                 Stopwatch stopWatch = new Stopwatch();

  1271.                                 //Log($"图像预处理", $"相机2-{Cam2Cnt}", WarningEnum.Normal, false);

  1272.                                 string time = "";

  1273.                                 stopWatch.Start(); 

  1274.                                 //图像镜像

  1275.                                 if (confMgr.SysConfigParams.Cam2_flipX && confMgr.SysConfigParams.Cam2_flipY)

  1276.                                 {

  1277.                                     img = img.Flip(FlipMode.XY);

  1278.                                     //Cv2.Flip(img, img, FlipMode.XY);//翻转

  1279.                                 }

  1280.                                 else if (confMgr.SysConfigParams.Cam2_flipX)

  1281.                                 {

  1282.                                     img = img.Flip(FlipMode.X);

  1283.                                     //Cv2.Flip(img, img, FlipMode.X);//翻转

  1284.                                 }

  1285.                                 else if (confMgr.SysConfigParams.Cam2_flipY)

  1286.                                 {

  1287.                                     img = img.Flip(FlipMode.Y);

  1288.                                     //Cv2.Flip(img, img, FlipMode.Y);//翻转 

  1289.                                 }

  1290.                                 time += $"->相机2翻转({stopWatch.ElapsedMilliseconds})";

  1291.                                 //显示

  1292.                                 //OnAutoRuning(new RunEventArgs(2, img));

  1293.                                 //lock (_lockOpenCV)

  1294.                                 {

  1295.                                     //存在数据队列

  1296.                                     if (currKey != 0 || htTask.ContainsKey(currKey))

  1297.                                     {

  1298.                                         //保存图片

  1299.                                         if (confMgr.SysConfigParams.CamImag.AutoSave && !string.IsNullOrEmpty(confMgr.SysConfigParams.CamImag.SavePath))

  1300.                                         {

  1301.                                             Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  1302.                                             string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.CamImag.SavePath, new List<string> { $"{curRecord.BarCode}_{curRecord.BarCodeName}" });

  1303.                                             //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(img).Save($"{dirPath}Cam2-{Cam2Cnt}.bmp", ImageFormat.Bmp);

  1304. 

  1305.                                             AddImageSave($"{dirPath}Cam2-{Cam2Cnt}.bmp", img);

  1306.                                         }

  1307.                                         if (_matList2.Count > listCntMax)

  1308.                                         {

  1309.                                             Log($"堆积过多", $"相机2-缓存{_matList2.Count}大于{listCntMax}", WarningEnum.High);

  1310.                                             //_matList2.Dequeue();

  1311.                                             System.GC.Collect();

  1312.                                         }

  1313.                                         

  1314.                                         int errStep = 0;

  1315.                                         Mat mat = img;

  1316.                                         try

  1317.                                         {

  1318.                                             errStep = 1;

  1319. 

  1320.                                             //反转+相机索引调换

  1321.                                             //lock (_lockOpenCV)

  1322.                                             {

  1323.                                                 //裁边，两侧和中间重合部分 

  1324.                                                 if (confMgr.SysConfigParams.MidCoin > 0)//中间重合部分

  1325.                                                 {

  1326.                                                     errStep = 3;

  1327.                                                     int width = mat.Width - confMgr.SysConfigParams.MidCoin / 2;

  1328.                                                     mat = OpencvUtils.CutImage(mat, confMgr.SysConfigParams.MidCoin / 2, 0, width, mat.Height);

  1329.                                                     time += $"->相机2-去重({stopWatch.ElapsedMilliseconds})";

  1330.                                                 }

  1331.                                             }

  1332.                                             errStep = 4;

  1333.                                             //右裁边

  1334.                                             int marginWidth0;

  1335.                                             mat = OpencvUtils.getMaxInsetRect2(mat, false, confMgr.SysConfigParams.HolePx, out marginWidth0);

  1336.                                             //存储裁边异常相机图 差异5cm

  1337.                                             if (_marginWidth2 == 0)

  1338.                                                 _marginWidth2 = marginWidth0;

  1339.                                             if (!confMgr.SysConfigParams.CamImag.AutoSave && Math.Abs(marginWidth0 - _marginWidth2) > (10 * confMgr.SysConfigParams.Cm2px_x) && !string.IsNullOrEmpty(confMgr.SysConfigParams.CamImag.SavePath))

  1340.                                             {

  1341.                                                 Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  1342.                                                 string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.CamImag.SavePath, new List<string> { $"{curRecord.BarCode}_{curRecord.BarCodeName}" });

  1343.                                                 AddImageSave($"{dirPath}Cam2-{Cam2Cnt}.bmp", img);

  1344.                                                 Log($"图像预处理", $"(相机2-图像{Cam2Cnt})-裁边异常：{marginWidth0}-{_marginWidth2} 》 {10 * confMgr.SysConfigParams.Cm2px_x}", WarningEnum.Normal, false);

  1345.                                             }

  1346.                                             _marginWidth2 = marginWidth0;

  1347.                                             errStep = 5;

  1348.                                             time += $"->相机2裁边({stopWatch.ElapsedMilliseconds})";

  1349.                                             Log($"图像预处理", $"(相机2-图像{Cam2Cnt})-右图去重后：{mat.Width}*{mat.Height}，" + $"重复值：{confMgr.SysConfigParams.MidCoin / 2} + 时间{time}", WarningEnum.Normal, false);

  1350.                                         }

  1351.                                         catch (Exception e)

  1352.                                         {

  1353.                                             Log($"图像处理", $"异常({errStep})：(相机2-图像{Cam2Cnt})-{e.Message}", WarningEnum.High);

  1354.                                         }

  1355.                                         //Log($"图像2入队列", $"相机2-{Cam1Cnt}", WarningEnum.Normal, false);

  1356.                                         //Cv2.Flip(img, img, FlipMode.XY);//翻转

  1357.                                         _matList2.Enqueue(new ScanPhotoInfo(1, Cam2Cnt++, mat.Clone(), picDis));

  1358.                                         //System.GC.Collect();

  1359.                                     }

  1360.                                     else

  1361.                                         Log($"相机2", $"(图像)-未扫码，图像丢弃！", WarningEnum.Low);

  1362.                                 }

  1363. 

  1364.                             }

  1365. 

  1366. #endregion

  1367.                             //System.GC.Collect();

  1368.                             Thread.Sleep(50);

  1369.                         } while (!isBreakProcessRun());

  1370.                         //暂停中断

  1371.                         //stopWatch.Stop();

  1372.                         pStopWatch.Stop();

  1373.                         //_isRuning = false;

  1374.                     }

  1375.                     else

  1376.                     {

  1377.                         //防止内存爆满

  1378.                         AcquisitionMat acq = _LinecamDev2.GetFrames(10);

  1379.                     }

  1380.                     Thread.Sleep(50);

  1381.                 }

  1382.                 catch (Exception e)

  1383.                 {

  1384.                     _isRuning = false;

  1385. 

  1386.                     Log("运行报警", "相机1流程运行出错：" + e.Message + "\n", WarningEnum.High);

  1387.                 }

  1388.             }

  1389.         }

  1390.         #endregion

  1391. 

  1392.         #region 处理线程

  1393.         int testCnt = 0;

  1394.         /// <summary>

  1395.         /// 后台运行主线程

  1396.         /// </summary>

  1397.         private void MainThreadFunction()

  1398.         {

  1399.             Mat acq1 = new Mat();

  1400.             Mat acq2 = new Mat();

  1401. #if Online

  1402. #else

  1403.             string imgfilePath1 = "D:\\CPL\\img\\L1.bmp";

  1404.             string imgfilePath2 = "D:\\CPL\\img\\R1.bmp";

  1405.             Mat timg1 = new Mat(imgfilePath1);

  1406.             timg1 = timg1.Flip(FlipMode.XY);

  1407.             Mat timg2 = new Mat(imgfilePath2);

  1408.             timg2 = timg1.Flip(FlipMode.XY);

  1409. #endif

  1410.             while (true)

  1411.             {

  1412.                 int errStep = 0;

  1413.                 try

  1414.                 {

  1415.                     if (_cts.IsCancellationRequested)

  1416.                         break;

  1417. 

  1418.                     if (IsRuning)

  1419.                     {

  1420.                         ////暂停开始

  1421.                         //stopWatch.Start();

  1422.                         do

  1423.                         {

  1424.                             

  1425. #if Online_One

  1426.                             #region 等待图片

  1427. #if Online

  1428.                             //采集图片

  1429.                             AcquisitionMat varacq1 = _LinecamDev1.GetFrames(10);

  1430.                             AcquisitionMat varacq2 = _LinecamDev2.GetFrames(10);

  1431. #else

  1432.                             AcquisitionMat varacq1 = new AcquisitionMat();

  1433.                             {

  1434.                                 varacq1.GrabStatus = "GrabPass";

  1435.                                 varacq1.Image = timg1;

  1436.                                 Log($"图像预处理", $"模拟相机1-{Cam1Cnt}", WarningEnum.Normal, true);

  1437.                             }

  1438.                             AcquisitionMat varacq2 = new AcquisitionMat();

  1439.                             {

  1440.                                 varacq2.GrabStatus = "GrabPass";

  1441.                                 varacq2.Image = timg2;

  1442.                                 Log($"图像预处理", $"模拟相机2-{Cam2Cnt}", WarningEnum.Normal, true);

  1443.                             }

  1444. 

  1445. 

  1446. #endif

  1447.                             if (varacq1.GrabStatus == "GrabPass")

  1448.                             {

  1449.                                 acq1 = varacq1.Image.Clone();

  1450.                                 _isHaveImgL = true;

  1451.                                 Cam1Cnt++;

  1452.                             }

  1453.                             if (varacq2.GrabStatus == "GrabPass")

  1454.                             {

  1455.                                 acq2 = varacq2.Image.Clone();

  1456.                                 _isHaveImgR = true;

  1457.                                 Cam2Cnt++;

  1458.                             }

  1459.                             

  1460.                             if (_isHaveImgL && _isHaveImgR)

  1461.                             {

  1462.                                 errStep = 1;

  1463.                                 Stopwatch stopWatch = new Stopwatch();

  1464.                                 string time = "";

  1465.                                 Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  1466.                                 try

  1467.                                 {

  1468.                                     if (Cam1Cnt != Cam2Cnt)

  1469.                                     {

  1470.                                         Log($"图像预处理", $"图像错位{Cam1Cnt}-{Cam2Cnt}", WarningEnum.High);

  1471.                                         continue;

  1472.                                     }

  1473.                                     

  1474.                                     #region 处理2次判定

  1475. 

  1476.                                     if (!confMgr.SysConfigParams.OpenLengthCountStop)

  1477.                                     {

  1478.                                         //处理2次判定

  1479.                                         //暂停:瑕疵二次判断

  1480.                                         if (DefectPauseForUser)

  1481.                                         {

  1482.                                             stopWatch.Restart();

  1483.                                             errStep = 2;

  1484.                                             int liPhotoIndex = Cam1Cnt - confMgr.SysConfigParams.StopImageCnt - 1;

  1485.                                             if (liPhotoIndex >= 0 && curRecord.dicPhoto_Defect.ContainsKey(liPhotoIndex) && curRecord.dicPhoto_Defect[liPhotoIndex] && curRecord.DefectInfoList != null)

  1486.                                             {

  1487.                                                 if (defectPuaseList.Count > 0)

  1488.                                                 {

  1489.                                                     errStep = 3;

  1490.                                                     List<DefectInfo> lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1491.                                                     Log($"二次判断2", $"(图像{liPhotoIndex})已达观察台，瑕疵二次判断=》({string.Join(",", lstEditDefect.Select(m => m.Code).ToArray())})是否包含在({string.Join(",", curRecord.ProductInfo.DefectPauseOption.ToArray())})中。", WarningEnum.Normal, false);

  1492.                                                     //瑕疵选项过滤

  1493.                                                     if (curRecord.ProductInfo.DefectPauseOption.Count == 0 || lstEditDefect.Where(x => curRecord.ProductInfo.DefectPauseOption.Contains(x.Code)).Count() > 0)

  1494.                                                     {

  1495.                                                         Log($"二次判断2", $"(图像{liPhotoIndex})需瑕疵二次判断，已达观察台，进入暂停。速度:{GetSpd()}");

  1496.                                                         // if (lstEditDefect.Where(x => x.Code == "jietou").Count() > 0)

  1497.                                                         if (lstEditDefect.Where(x => DefectItemsPuaseNameList.Contains(x.Name)).Count() > 0)

  1498.                                                         {

  1499.                                                             Stop();

  1500.                                                             //获取完整数据

  1501.                                                             Thread.Sleep(500);

  1502.                                                             lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1503.                                                             //获取完整数据

  1504.                                                             #region 二级界面

  1505.                                                             #region 加载界面

  1506.                                                             if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  1507.                                                             {

  1508.                                                                 var pimage = (Bitmap)defectPuaseImgList[liPhotoIndex].ToBitmap().Clone();

  1509.                                                                 var pmat = defectPuaseImgList[liPhotoIndex].Clone();

  1510.                                                                 Task.Run(() =>

  1511.                                                                 {

  1512.                                                                     int liDefectCount = lstEditDefect.Count;

  1513.                                                                     ImageShowFrm frmDefect = new ImageShowFrm(lstEditDefect, pimage);

  1514.                                                                     //frmDefect.Show();

  1515.                                                                     if (frmDefect.ShowDialog(_FatherFrm) == DialogResult.OK)

  1516.                                                                     {

  1517. 

  1518.                                                                         SysMgr.Instance.DelDefectEdit(curRecord, frmDefect.lstDel);

  1519. 

  1520.                                                                         OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat, frmDefect.lstDel));

  1521.                                                                         //double len = (double)this.lblLen.Tag;

  1522.                                                                         //this.reDrawDefectPoints(curRecord.DefectInfoList, new double[] { 0, Math.Round(curRecord.FaceWidthMax + 0.005f, 2) }, new double[] { 0, len });

  1523.                                                                         Log($"二次检测2", $"本次忽略{frmDefect.lstDel.Count}个瑕疵，本张图由{liDefectCount} -> {lstEditDefect.Count}，总数{curRecord.DefectInfoList.Count}");

  1524.                                                                     }

  1525.                                                                     else

  1526.                                                                     {

  1527.                                                                         OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, pmat, null));

  1528.                                                                     }

  1529.                                                                 });

  1530.                                                             }

  1531.                                                             else

  1532.                                                                 Log($"二次检测2", $"本次图像已检测完成");

  1533.                                                             #endregion

  1534.                                                             //OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, defectPuaseImgList[liPhotoIndex]));

  1535.                                                             #endregion

  1536.                                                         }

  1537.                                                         errStep = 3;

  1538. 

  1539.                                                     }

  1540.                                                     Log($"二次判断删除", $"{liPhotoIndex}-{testCnt}", WarningEnum.Normal, false);

  1541. 

  1542.                                                     lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1543. 

  1544.                                                     if (lstEditDefect.Count > 0 && defectPuaseImgList.Count > 0)

  1545.                                                     {

  1546.                                                         Mat mt;

  1547.                                                         defectPuaseImgList.TryRemove(lstEditDefect[0].PhotoIndex, out mt);

  1548.                                                     }

  1549.                                                     //foreach (var item in lstEditDefect)

  1550.                                                     {

  1551.                                                         lock (lock_defectPuase)

  1552.                                                         {

  1553.                                                             defectPuaseList.RemoveAll(m => m.PhotoIndex == liPhotoIndex);

  1554.                                                             //defectPuaseList.Remove(item);

  1555.                                                         }

  1556.                                                     }

  1557. 

  1558.                                                 }

  1559.                                                 else

  1560.                                                     Log($"二次判断2", $"(图像{liPhotoIndex})-缺陷未获得", WarningEnum.Low, false);

  1561.                                             }

  1562.                                             Log($"图像预处理", $"(图像{Cam1Cnt - 1})-处理2次判定:{stopWatch.ElapsedMilliseconds}", WarningEnum.Normal, false);

  1563.                                             //else

  1564.                                             //    Log($"二次判断2", $"(图像{liPhotoIndex})-处理未跟上", WarningEnum.Low, false);

  1565.                                         }

  1566.                                         //time += $"->处理2次判定({stopWatch.ElapsedMilliseconds})";

  1567.                                     }

  1568. 

  1569.                                     #endregion

  1570. 

  1571.                                     #region 相机图片保存

  1572.                                     errStep = 4;

  1573.                                     //保存图片

  1574.                                     if (confMgr.SysConfigParams.CamImag.AutoSave && !string.IsNullOrEmpty(confMgr.SysConfigParams.CamImag.SavePath))

  1575.                                     {

  1576.                                         stopWatch.Restart();

  1577.                                         string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.CamImag.SavePath, new List<string> { $"{curRecord.BarCode}_{curRecord.BarCodeName}" });

  1578. 

  1579.                                         AddImageSave($"{dirPath}Cam1-{Cam1Cnt}.bmp", acq1);

  1580.                                         AddImageSave($"{dirPath}Cam2-{Cam2Cnt}.bmp", acq2);

  1581.                                         Log($"图像预处理", $"(图像{Cam1Cnt - 1})-相机图片保存:{stopWatch.ElapsedMilliseconds}", WarningEnum.Normal, false);

  1582.                                     }

  1583.                                     if (_matList2.Count > listCntMax)

  1584.                                     {

  1585.                                         Log($"堆积过多", $"相机-缓存{_matList2.Count}大于{listCntMax}", WarningEnum.High);

  1586.                                         //_matList2.Dequeue();

  1587.                                         System.GC.Collect();

  1588.                                     }

  1589.                                     #endregion

  1590.                                     //预处理

  1591.                                     stopWatch.Restart();

  1592.                                     

  1593.                                     #region 去重

  1594.                                     if (confMgr.SysConfigParams.MidCoin > 0)//中间重合部分

  1595.                                     {

  1596.                                         errStep = 6;

  1597.                                         int width = acq1.Width - confMgr.SysConfigParams.MidCoin / 2;

  1598.                                         acq1 = OpencvUtils.CutImage(acq1, confMgr.SysConfigParams.MidCoin / 2, 0, width, acq1.Height);

  1599.                                         acq2 = OpencvUtils.CutImage(acq2, 0, 0, width, acq2.Height);

  1600.                                         time += $"->相机-去重({stopWatch.ElapsedMilliseconds})";

  1601.                                     }

  1602.                                     #endregion

  1603.                                     #region 裁边

  1604.                                     errStep = 7;

  1605.                                     //左裁边

  1606.                                     int marginWidth0;

  1607.                                     acq1 = OpencvUtils.getMaxInsetRect2(acq1, false, confMgr.SysConfigParams.HolePx, out marginWidth0);

  1608.                                     //右裁边

  1609.                                     acq2 = OpencvUtils.getMaxInsetRect2(acq2, true, confMgr.SysConfigParams.HolePx, out marginWidth0);

  1610.                                     time += $"->相机裁边({stopWatch.ElapsedMilliseconds})";

  1611.                                     #endregion

  1612.                                     #region 拼接

  1613.                                     errStep = 8;

  1614.                                     //水平合并l

  1615.                                     Mat mat;

  1616.                                     mat = OpencvUtils.MergeImage_sameSize(new Mat[] { acq2, acq1 });

  1617.                                     time += $"->图1+2合并({stopWatch.ElapsedMilliseconds})";

  1618.                                     #endregion

  1619.                                     #region 镜像

  1620.                                     errStep = 5;

  1621.                                     //图像镜像

  1622.                                     mat = mat.Flip(FlipMode.XY);

  1623.                                     time += $"->相机翻转({stopWatch.ElapsedMilliseconds})";

  1624.                                     #endregion

  1625.                                     #region 填充

  1626.                                     errStep = 9;

  1627.                                     //比例缩放图片

  1628.                                     int xw;

  1629.                                     int resizeWidth = OpencvUtils.GetWidthForResize(acq1.Width + acq2.Width - confMgr.SysConfigParams.MidCoin);

  1630.                                     if (resizeWidth == 0)

  1631.                                         throw new Exception("GetWidthForResize result 0 失败!");

  1632.                                     var resize = new System.Drawing.Size(resizeWidth, OpencvUtils.image_height * 2);//固定8192*2张*4096

  1633.                                     mat = OpencvUtils.Resize(mat, resize.Width, resize.Height, out xw);

  1634.                                     time += $"->填充({stopWatch.ElapsedMilliseconds})";

  1635.                                     #endregion

  1636.                                     #region 处理

  1637.                                     errStep = 10;

  1638.                                     defectLib.add(new DefectTask()

  1639.                                     {

  1640.                                         modelName = curRecord.ProductInfo.ModelName,

  1641.                                         record = curRecord,

  1642.                                         bmp = mat,

  1643.                                         bmpTag = mat.Clone(),

  1644.                                         photoIndex = Cam1Cnt - 1,//0-n 首张必需为0，因下面计算长度是从0开始

  1645.                                         widthRatio = 1.0f,//等比例缩放，高度不变

  1646.                                         qualifiedLimitList = curRecord.ProductInfo.QualifiedLimitList,

  1647.                                         labelDic = GetDefectCode(),

  1648.                                         finishEvent = callBackDefectEvent,

  1649.                                         xw = xw,

  1650.                                         cm2px_x = confMgr.SysConfigParams.Cm2px_x,

  1651.                                         cm2px_y = confMgr.SysConfigParams.Cm2px_y,

  1652.                                         expand_pixel = confMgr.SysConfigParams.Expand_pixel,

  1653.                                     });

  1654.                                     curRecord.ScannerPhotoCount++;

  1655.                                     errStep = 11;

  1656.                                     time += $"->加入瑕疵待检队列({stopWatch.ElapsedMilliseconds})";

  1657.                                     #endregion

  1658.                                     #region 门幅

  1659.                                     float faceWidthX_cm = (float)Math.Round((Cam1Cnt) * mat.Height * 1.0f / confMgr.SysConfigParams.Cm2px_y, 2);

  1660.                                     float faceWidthY_cm = (float)Math.Round((mat.Width + confMgr.SysConfigParams.HolePx * 2) * 1.0f / confMgr.SysConfigParams.Cm2px_x, 2);

  1661.                                     if (curRecord.FaceWidthMin == 0 || curRecord.FaceWidthMin > faceWidthY_cm)

  1662.                                         curRecord.FaceWidthMin = faceWidthY_cm;

  1663.                                     if (curRecord.FaceWidthMax < faceWidthY_cm)

  1664.                                         curRecord.FaceWidthMax = faceWidthY_cm;

  1665.                                     var point = new float[] { faceWidthX_cm, faceWidthY_cm };

  1666.                                     curRecord.FacePointList.Add(point);

  1667.                                     errStep = 12;

  1668.                                     //判定门幅

  1669.                                     //if (x < XSizeRange[0]) 

  1670.                                     //    Log($"绘图", $"门幅宽度超限 1！！！！ {x}<{XSizeRange[0]}", WarningEnum.High);

  1671.                                     //if (x > XSizeRange[1])

  1672.                                     //    Log($"绘图", $"门幅宽度超限 2！！！！ {x}>{XSizeRange[1]}", WarningEnum.High);

  1673.                                     //if (item[1] < YSizeRange[0])

  1674.                                     //    Log($"绘图", $"门幅宽度超限 3！！！！ {item[1]}<{YSizeRange[0]}", WarningEnum.High);

  1675.                                     //if (item[1] > YSizeRange[1])

  1676.                                     //    Log($"绘图", $"门幅宽度超限 4！！！！ {item[1]}>{YSizeRange[1]}", WarningEnum.High);

  1677. 

  1678.                                     //显示门幅绘图

  1679.                                     OnAutoRuning(new RunEventArgs(curRecord.FacePointList));

  1680.                                     errStep = 13;

  1681.                                     time += $"->门幅刷新({stopWatch.ElapsedMilliseconds})";

  1682.                                     #endregion

  1683.                                     #region 长度剩余提醒

  1684.                                     errStep = 14;

  1685.                                     //长度剩余提醒

  1686.                                     if (CurrProductModel.residueWarnningLen > 0 && curRecord.ErpLen > 0 && CurrProductModel.residueWarnningLen >= curRecord.ErpLen - curRecord.Len)

  1687.                                     {

  1688.                                         Log($"长度告警", $"已达剩余长度不足提醒!({curRecord.ErpLen - curRecord.Len}<={CurrProductModel.residueWarnningLen})", WarningEnum.Low);

  1689.                                     }

  1690.                                     #endregion

  1691.                                 }

  1692.                                 catch (Exception ex)

  1693.                                 {

  1694.                                     curRecord.ScannerPhotoFinishCount++;//失败时不能因数量不一致无法保存

  1695.                                     Log($"图像预处理", $"异常({errStep})：(图像{Cam1Cnt-1})-{ex.Message}", WarningEnum.High);

  1696.                                     //string dirPath = FileUtil.initFolder($"{Config.ImagePath}{curRecord.BatchId}_{curRecord.ReelId}\\Err\\");

  1697.                                     //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(scanPhotos0.mat).Save($"{dirPath}{scanPhotos0.photoIndex}_0_Step{errStep}.bmp", ImageFormat.Bmp);

  1698.                                     //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(scanPhotos1.mat).Save($"{dirPath}{scanPhotos1.photoIndex}_1_Step{errStep}.bmp", ImageFormat.Bmp);

  1699.                                 }

  1700.                                 finally

  1701.                                 {

  1702.                                     Log($"图像预处理", $"(图像{Cam1Cnt - 1})-进度计时:{time}", WarningEnum.Normal, false);

  1703.                                     //task = null;

  1704.                                     //System.GC.Collect();

  1705.                                 }

  1706.                             }

  1707.                             else

  1708.                                 continue;

  1709. 

  1710.                             #endregion

  1711. #else

  1712.                             #region 长度剩余提醒

  1713.                             //长度剩余提醒

  1714.                             Records curRecord = Hashtable.Synchronized(htTask)[currKey] as Records;

  1715.                             if (CurrProductModel.residueWarnningLen > 0 && curRecord.ErpLen > 0 && CurrProductModel.residueWarnningLen >= curRecord.ErpLen - curRecord.Len)

  1716.                             {

  1717.                                 Log($"长度告警", $"已达剩余长度不足提醒!({curRecord.ErpLen - curRecord.Len}<={CurrProductModel.residueWarnningLen})", WarningEnum.Low);

  1718.                             }

  1719.                             #endregion

  1720. 

  1721.                             #region 图像裁边预处理

  1722.                             //预处理,队列都有数据，且数据长度一致

  1723. #if Online_defect

  1724.                             ScanPhotoInfo peek1;

  1725.                             ScanPhotoInfo peek2;

  1726.                             

  1727.                             if (_matList1.Count > 0 && _matList2.Count > 0 )

  1728.                             {

  1729.                                 _matList1.TryPeek(out peek1);

  1730.                                 _matList2.TryPeek(out peek2);

  1731.                                 if (peek1 != null && peek2 !=null && peek1.photoIndex != peek2.photoIndex)

  1732.                                     continue;

  1733.                                 Stopwatch stopWatch = new Stopwatch();

  1734.                                 ScanPhotoInfo scanPhotos0; 

  1735.                                 if(!_matList1.TryDequeue(out scanPhotos0))

  1736.                                     Log($"图像出队列", $"异常相机1队列出队失败", WarningEnum.High);

  1737.                                 ScanPhotoInfo scanPhotos1;

  1738.                                 if(!_matList2.TryDequeue(out scanPhotos1))

  1739.                                     Log($"图像出队列", $"异常相机2队列出队失败", WarningEnum.High);

  1740. 

  1741.                                 //Log($"图像出队列", $"相机1-{scanPhotos0.photoIndex}", WarningEnum.Normal, false);

  1742.                                 curRecord.dicPhoto_Defect.TryAdd(scanPhotos0.photoIndex, false);//加入索引，默认无瑕疵

  1743.                                

  1744.                                 //Log($"图像拼接处理", $"相机1-{scanPhotos0.photoIndex},相机2-{scanPhotos1.photoIndex}", WarningEnum.Normal, false);

  1745. 

  1746.                                 string time = $"图像位置:{scanPhotos1.CurrDis}";

  1747.                                 stopWatch.Start();

  1748.                                 try

  1749.                                 {

  1750.                                     Mat mat;

  1751.                                     Mat mat0;

  1752.                                     Mat mat1;

  1753.                                     //lock (_lockOpenCV)

  1754.                                     {

  1755.                                         if (scanPhotos0.mat.Height != scanPhotos1.mat.Height)

  1756.                                         {

  1757.                                             Log($"警告", $"两相机采集图高度不一致({scanPhotos0.photoIndex}),dev1.Height={scanPhotos0.mat.Height},dev2.Height={scanPhotos1.mat.Height},重新resize...", WarningEnum.Low);

  1758.                                             if (scanPhotos0.mat.Height > scanPhotos1.mat.Height)

  1759.                                                 scanPhotos1.mat = OpencvUtils.ResizeMat(scanPhotos1.mat, scanPhotos0.mat.Width, scanPhotos0.mat.Height);

  1760.                                             else

  1761.                                                 scanPhotos0.mat = OpencvUtils.ResizeMat(scanPhotos0.mat, scanPhotos1.mat.Width, scanPhotos1.mat.Height);

  1762.                                         }

  1763.                                         errStep = 1;

  1764. 

  1765.                                         //反转+相机索引调换

  1766.                                         mat1 = scanPhotos1.mat;

  1767.                                         mat0 = scanPhotos0.mat;

  1768. 

  1769.                                         //水平合并l

  1770.                                         mat = OpencvUtils.MergeImage_sameSize(new Mat[] { mat0, mat1 });//这里相机反装，左右反转下

  1771.                                         //Log($"合并", $"(图像{scanPhotos0.photoIndex})-裁边去孔洞后:({mat0.Width}+{mat1.Width});合并后(去孔洞)：{mat.Width}*{mat.Height}", WarningEnum.Normal, false);

  1772.                                         //float widthRatio = mat.Width * 1.0f / resize.Width;//宽度比例

  1773.                                         time += $"->图1+2合并({stopWatch.ElapsedMilliseconds})";

  1774.                                     }

  1775.                                     errStep = 2;

  1776.                                     //门幅更新（含两侧孔洞）x,y cm

  1777.                                     float faceWidthX_cm = (float)Math.Round((scanPhotos0.photoIndex + 1) * mat.Height * 1.0f / confMgr.SysConfigParams.Cm2px_y, 2);

  1778.                                     float faceWidthY_cm = (float)Math.Round((mat.Width + confMgr.SysConfigParams.HolePx * 2) * 1.0f / confMgr.SysConfigParams.Cm2px_x, 2);

  1779. #else

  1780.                             string imgfilePath = "C:\\Users\\fang\\Desktop\\新建文件夹\\boyi lou";

  1781. 

  1782.                             if (!Directory.Exists(imgfilePath))

  1783.                             {

  1784.                                 Log($"图像处理", $"模拟错误-路径错误{imgfilePath}", WarningEnum.High);

  1785.                                 break;

  1786.                             }

  1787.                             string[] files = Directory.GetFiles(imgfilePath, $"*.bmp", SearchOption.TopDirectoryOnly);

  1788. 

  1789.                             if (files.Length > 0 && Cam1Cnt < files.Length)

  1790.                             {

  1791.                                 Stopwatch stopWatch = new Stopwatch();

  1792.                                

  1793.                                 string time = "";

  1794.                                 //stopWatch.Start();

  1795. 

  1796.                                 ScanPhotoInfo scanPhotos0 = new ScanPhotoInfo(0, Cam1Cnt, new Mat(4096, 4096 * 2, MatType.CV_8UC3, new Scalar(0, 0, 0)));

  1797.                                 ScanPhotoInfo scanPhotos1 = new ScanPhotoInfo(1, Cam1Cnt, new Mat(4096, 4096 * 2, MatType.CV_8UC3, new Scalar(0, 0, 0)));

  1798. 

  1799.                                 stopWatch.Start();

  1800.                                 errStep = 0;

  1801.                                 try

  1802.                                 {

  1803.                                     Log($"图像处理", $"模拟{files[Cam1Cnt]}");

  1804.                                     Mat mat = new Mat(files[Cam1Cnt]);

  1805.                                     Cam1Cnt++;

  1806.                                     Mat mat0 = scanPhotos1.mat;

  1807.                                     Mat mat1 = scanPhotos0.mat;       

  1808. 

  1809.                                     float faceWidthX_cm = (float)Math.Round((scanPhotos0.photoIndex + 1) * mat.Height * 1.0f / confMgr.SysConfigParams.Cm2px_y, 2);

  1810.                                     float faceWidthY_cm = (float)Math.Round((mat.Width + confMgr.SysConfigParams.HolePx * 2) * 1.0f / confMgr.SysConfigParams.Cm2px_x, 2);

  1811. #endif

  1812.                                     //显示图片

  1813.                                     //OnAutoRuning(new RunEventArgs(mat.Clone()));

  1814. 

  1815.                                     //faceWidthX_cm = (float)Math.Round(faceWidthX_cm, 2);

  1816.                                     //faceWidthY_cm = (float)Math.Round(faceWidthY_cm, 2);

  1817.                                     if (curRecord.FaceWidthMin == 0 || curRecord.FaceWidthMin > faceWidthY_cm)

  1818.                                         curRecord.FaceWidthMin = faceWidthY_cm;

  1819.                                     if (curRecord.FaceWidthMax < faceWidthY_cm)

  1820.                                         curRecord.FaceWidthMax = faceWidthY_cm;

  1821.                                     var point = new float[] { faceWidthX_cm, faceWidthY_cm };// new System.Drawing.PointF(faceWidthX_cm, faceWidthY_cm);

  1822.                                     //Log($"门幅", $"(图像{scanPhotos0.photoIndex})-({scanPhotos0.photoIndex})位置：{point[0]}; 幅宽：{point[1]}", WarningEnum.Normal, false);

  1823.                                     curRecord.FacePointList.Add(point);

  1824.                                     errStep = 3;

  1825.                                     //判定门幅

  1826.                                     //if (x < XSizeRange[0]) 

  1827.                                     //    Log($"绘图", $"门幅宽度超限 1！！！！ {x}<{XSizeRange[0]}", WarningEnum.High);

  1828.                                     //if (x > XSizeRange[1])

  1829.                                     //    Log($"绘图", $"门幅宽度超限 2！！！！ {x}>{XSizeRange[1]}", WarningEnum.High);

  1830.                                     //if (item[1] < YSizeRange[0])

  1831.                                     //    Log($"绘图", $"门幅宽度超限 3！！！！ {item[1]}<{YSizeRange[0]}", WarningEnum.High);

  1832.                                     //if (item[1] > YSizeRange[1])

  1833.                                     //    Log($"绘图", $"门幅宽度超限 4！！！！ {item[1]}>{YSizeRange[1]}", WarningEnum.High);

  1834. 

  1835.                                     //显示门幅绘图

  1836.                                     OnAutoRuning(new RunEventArgs(curRecord.FacePointList));

  1837.                                     errStep = 7;

  1838.                                     time += $"->门幅刷新({stopWatch.ElapsedMilliseconds})";

  1839.                                     //去除两侧孔洞（门幅计算时不能去除）

  1840.                                     //if (Config.MarginHoleWidth > 0) 

  1841.                                     //    mat = OpenCVUtil.cutImage(mat, Config.MarginHoleWidth, 0, mat.Width - Config.MarginHoleWidth * 2, mat.Height); 

  1842. 

  1843.                                     #region 速度

  1844.                                     //计算速度 

  1845.                                     if (!confMgr.SysConfigParams.OpenLengthCount)

  1846.                                     {

  1847.                                         double lenMi = Math.Round(faceWidthX_cm / 100, 2);

  1848.                                         curRecord.Len = lenMi;

  1849.                                         curRecord.TimeLen = pStopWatch.ElapsedMilliseconds / 1000.0d / 60.0d;//总时间 分

  1850.                                         double aveSpd = Math.Round(lenMi / curRecord.TimeLen, 2);

  1851.                                         //显示平均速度

  1852.                                         OnAutoRuning(new RunEventArgs(lenMi, aveSpd));

  1853.                                         errStep = 9;

  1854.                                         time += $"->速度刷新({stopWatch.ElapsedMilliseconds})";

  1855.                                     }

  1856. 

  1857.                                     #endregion

  1858. #if false

  1859.                                     #region 处理2次判定

  1860.                                     if (!confMgr.SysConfigParams.OpenLengthCountStop)

  1861.                                     {

  1862.                                         //处理2次判定

  1863.                                         //暂停:瑕疵二次判断

  1864.                                         if (DefectPauseForUser && defectPuaseList.Count > 0)

  1865.                                         {

  1866.                                             errStep = 11;

  1867.                                             int liPhotoIndex = scanPhotos0.photoIndex - confMgr.SysConfigParams.StopImageCnt;

  1868.                                             //Log($"二次判断2", $"图像{scanPhotos0.photoIndex}  {liPhotoIndex}={scanPhotos0.photoIndex}-{confMgr.SysConfigParams.StopImageCnt}；{JsonConvert.SerializeObject(curRecord.dicPhoto_Defect)}", WarningEnum.Normal, false);

  1869.                                             if (liPhotoIndex >= 0 && curRecord.dicPhoto_Defect[liPhotoIndex] && curRecord.DefectInfoList != null)

  1870.                                             {

  1871.                                                 errStep = 12;

  1872.                                                 List<DefectInfo> lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1873.                                                 Log($"二次判断2", $"(图像{liPhotoIndex})已达观察台，瑕疵二次判断=》({string.Join(",", lstEditDefect.Select(m => m.Code).ToArray())})是否包含在({string.Join(",", curRecord.ProductInfo.DefectPauseOption.ToArray())})中。", WarningEnum.Normal, false);

  1874.                                                 //瑕疵选项过滤

  1875.                                                 if (curRecord.ProductInfo.DefectPauseOption.Count == 0 || lstEditDefect.Where(x => curRecord.ProductInfo.DefectPauseOption.Contains(x.Code)).Count() > 0) 

  1876.                                                 {

  1877.                                                     Log($"二次判断2", $"(图像{liPhotoIndex})需瑕疵二次判断，已达观察台，进入暂停。");

  1878.                                                    // if (lstEditDefect.Where(x => x.Code == "jietou").Count() > 0)

  1879.                                                     if (lstEditDefect.Where(x => DefectItemsPuaseNameList.Contains(x.Name)).Count() > 0)

  1880.                                                     {

  1881.                                                         Stop();

  1882.                                                         //获取完整数据

  1883.                                                         Thread.Sleep(500);

  1884.                                                         lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1885.                                                         //获取完整数据

  1886.                                                         #region 二级界面

  1887.                                                         #region 加载界面

  1888.                                                         if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  1889.                                                         {

  1890.                                                             var pimage = (Bitmap)defectPuaseImgList[liPhotoIndex].ToBitmap().Clone();

  1891.                                                             Task.Run(() =>

  1892.                                                             {

  1893.                                                                 int liDefectCount = lstEditDefect.Count;

  1894.                                                                 ImageShowFrm frmDefect = new ImageShowFrm(lstEditDefect, pimage);

  1895.                                                                 //frmDefect.Show();

  1896.                                                                 if (frmDefect.ShowDialog() == DialogResult.OK)

  1897.                                                                 {

  1898. 

  1899.                                                                     SysMgr.Instance.DelDefectEdit(curRecord, frmDefect.lstDel);

  1900. 

  1901.                                                                     OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, defectPuaseImgList[liPhotoIndex], frmDefect.lstDel));

  1902.                                                                     //double len = (double)this.lblLen.Tag;

  1903.                                                                     //this.reDrawDefectPoints(curRecord.DefectInfoList, new double[] { 0, Math.Round(curRecord.FaceWidthMax + 0.005f, 2) }, new double[] { 0, len });

  1904.                                                                     Log($"二次检测2", $"本次忽略{frmDefect.lstDel.Count}个瑕疵，本张图由{liDefectCount} -> {lstEditDefect.Count}，总数{curRecord.DefectInfoList.Count}");

  1905.                                                                 }

  1906.                                                                 else

  1907.                                                                 {

  1908.                                                                     OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, defectPuaseImgList[liPhotoIndex], null));

  1909.                                                                 }

  1910.                                                             });

  1911.                                                         }

  1912.                                                         else

  1913.                                                             Log($"二次检测2", $"本次图像已检测完成");

  1914.                                                         #endregion

  1915.                                                         //OnAutoRuning(new RunEventArgs(liPhotoIndex, lstEditDefect, curRecord, defectPuaseImgList[liPhotoIndex]));

  1916.                                                         #endregion

  1917.                                                     }

  1918.                                                     errStep = 18;

  1919. 

  1920.                                                 }

  1921.                                                 Log($"二次判断删除", $"{liPhotoIndex}-{testCnt}", WarningEnum.Normal, false);

  1922.                                                 lock (lock_defectPuase)

  1923.                                                 {

  1924.                                                     lstEditDefect = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  1925.                                                     if (lstEditDefect.Count > 0 && defectPuaseImgList.Count > 0)

  1926.                                                         defectPuaseImgList.Remove(lstEditDefect[0].PhotoIndex);

  1927.                                                     foreach (var item in lstEditDefect)

  1928.                                                     {

  1929.                                                         defectPuaseList.Remove(item);

  1930.                                                     }

  1931.                                                 }

  1932.                                             }

  1933.                                         }

  1934.                                         time += $"->处理2次判定({stopWatch.ElapsedMilliseconds})";

  1935.                                     }

  1936.                                     #endregion

  1937. #endif

  1938. 

  1939.                                     //----缺陷队列

  1940.                                     //比例缩放图片

  1941.                                     int xw;

  1942.                                     int resizeWidth = OpencvUtils.GetWidthForResize(mat0.Width + mat1.Width - confMgr.SysConfigParams.MidCoin);

  1943.                                     if (resizeWidth == 0)

  1944.                                         throw new Exception("GetWidthForResize result 0 失败!");

  1945.                                     var resize = new System.Drawing.Size(resizeWidth, OpencvUtils.image_height * 2);//固定8192*2张*4096

  1946.                                     mat = OpencvUtils.Resize(mat, resize.Width, resize.Height, out xw);

  1947.                                     //Log($"图像处理", $"(图像{scanPhotos0.photoIndex})-合成图resize后:{mat.Width}*{mat.Height}", WarningEnum.Normal, false);

  1948.                                     defectLib.add(new DefectTask()

  1949.                                     {

  1950.                                         modelName = curRecord.ProductInfo.ModelName,

  1951.                                         record = curRecord,

  1952.                                         bmp = mat,

  1953.                                         bmpTag = mat.Clone(),

  1954.                                         photoIndex = scanPhotos0.photoIndex,//0-n 首张必需为0，因下面计算长度是从0开始

  1955.                                         widthRatio = 1.0f,//等比例缩放，高度不变

  1956.                                         qualifiedLimitList = curRecord.ProductInfo.QualifiedLimitList,

  1957.                                         labelDic = GetDefectCode(),

  1958.                                         finishEvent = callBackDefectEvent,

  1959.                                         xw = xw,

  1960.                                         cm2px_x = confMgr.SysConfigParams.Cm2px_x,

  1961.                                         cm2px_y = confMgr.SysConfigParams.Cm2px_y,

  1962.                                         expand_pixel = confMgr.SysConfigParams.Expand_pixel,

  1963.                                         CurrDis = scanPhotos1.CurrDis,

  1964.                                     });

  1965.                                     curRecord.ScannerPhotoCount++;

  1966.                                     errStep = 10;

  1967.                                     time += $"->加入瑕疵待检队列({stopWatch.ElapsedMilliseconds})";

  1968.                                 }

  1969.                                 catch (Exception ex)

  1970.                                 {

  1971.                                     curRecord.ScannerPhotoFinishCount++;//失败时不能因数量不一致无法保存

  1972.                                     Log( $"图像处理", $"异常({errStep})：(图像{scanPhotos0.photoIndex})-{ex.Message}", WarningEnum.High);

  1973.                                     //string dirPath = FileUtil.initFolder($"{Config.ImagePath}{curRecord.BatchId}_{curRecord.ReelId}\\Err\\");

  1974.                                     //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(scanPhotos0.mat).Save($"{dirPath}{scanPhotos0.photoIndex}_0_Step{errStep}.bmp", ImageFormat.Bmp);

  1975.                                     //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(scanPhotos1.mat).Save($"{dirPath}{scanPhotos1.photoIndex}_1_Step{errStep}.bmp", ImageFormat.Bmp);

  1976.                                 }

  1977.                                 finally

  1978.                                 {

  1979.                                     Log($"图像处理", $"(图像{scanPhotos0.photoIndex})-进度计时:{time}", WarningEnum.Normal, false);

  1980.                                     scanPhotos0.mat.Dispose();

  1981.                                     scanPhotos1.mat.Dispose();

  1982.                                     scanPhotos0 = scanPhotos1 = null;

  1983.                                     //task = null;

  1984.                                     //System.GC.Collect();

  1985.                                 }

  1986.                             }

  1987.                             #endregion

  1988. #endif

  1989.                             Thread.Sleep(20);

  1990.                         } while (!isBreakProcessRun());

  1991.                         //暂停中断

  1992.                         //stopWatch.Stop();

  1993.                         pStopWatch.Stop();

  1994.                         _isRuning = false;

  1995.                     }

  1996. #if Online_One

  1997.                     else

  1998.                     {

  1999.                         //防止内存爆满

  2000.                         AcquisitionMat tacq1 = _LinecamDev1.GetFrames(10);

  2001.                         AcquisitionMat tacq2 = _LinecamDev2.GetFrames(10);

  2002.                     }

  2003. #endif

  2004.                     Thread.Sleep(20);

  2005.                 }

  2006.                 catch (Exception e)

  2007.                 {

  2008.                     _isRuning = false;

  2009. 

  2010.                     Log("运行报警", $"流程运行出错{errStep}：" + e.Message + "\n", WarningEnum.High);

  2011.                 }

  2012.             }

  2013.         }

  2014.         #endregion

  2015. 

  2016.         #endregion

  2017. 

  2018.         #region 模型label

  2019.         private JArray _defectItemList;

  2020.         /// <summary>

  2021.         /// 获取模型对应标签信息

  2022.         /// </summary>

  2023.         private void GetDefectAllLabel()

  2024.         {

  2025.             string labels = CurrProductModel.ModelName.Replace(".trt", ".json");

  2026.             string configPath = confMgr.SysConfigParams.AIModelPath + $"\\{labels}";

  2027.             string lsTmp = File.ReadAllText(configPath);

  2028.             JArray defectItemList = JArray.Parse(lsTmp);

  2029.             _defectItemList = defectItemList;

  2030.             //var item = defectItemList.FirstOrDefault(m => m.Value<int>("id") == id);

  2031.             //if (item == null)

  2032.             //    return null;

  2033.             //return (JObject)item;

  2034.         }

  2035.         

  2036.         public JArray GetDefectItemList()

  2037.         { return _defectItemList; }

  2038.         /// <summary>

  2039.         /// 根据id获取标签信息

  2040.         /// </summary>

  2041.         /// <param name="id"></param>

  2042.         /// <returns></returns>

  2043.         public JObject GetDefectLabel(int id)

  2044.         {

  2045.             if (_defectItemList != null && _defectItemList.Count > 0)

  2046.             {

  2047.                 var item = _defectItemList.FirstOrDefault(m => m.Value<int>("id") == id);

  2048.                 if (item == null)

  2049.                     return null;

  2050.                 return (JObject)item;

  2051.             }

  2052.             else

  2053.                 return null;

  2054.         }

  2055.         /// <summary>

  2056.         /// 根据name获取标签信息

  2057.         /// </summary>

  2058.         /// <param name="id"></param>

  2059.         /// <returns></returns>

  2060.         public JObject GetDefectLabel(string name)

  2061.         {

  2062.             if (_defectItemList != null && _defectItemList.Count > 0)

  2063.             {

  2064.                 var item = _defectItemList.FirstOrDefault(m => m.Value<string>("name") == name);

  2065.                 if (item == null)

  2066.                     return null;

  2067.                 return (JObject)item;

  2068.             }

  2069.             else

  2070.                 return null;

  2071.         }

  2072.         public JObject GetDefectLabel(string modelName, string name)

  2073.         {

  2074.             string labels = modelName.Replace(".trt", ".json");

  2075.             string configPath = confMgr.SysConfigParams.AIModelPath + $"\\{labels}";

  2076.             string lsTmp = File.ReadAllText(configPath);

  2077.             JArray defectItemList = JArray.Parse(lsTmp);

  2078.             if (defectItemList != null && defectItemList.Count > 0)

  2079.             {

  2080.                 var item = defectItemList.FirstOrDefault(m => m.Value<string>("name") == name);

  2081.                 if (item == null)

  2082.                     return null;

  2083.                 return (JObject)item;

  2084.             }

  2085.             else

  2086.                 return null;

  2087.         }

  2088.         public string GetDefectName(string code)

  2089.         {

  2090.             if (_defectItemList != null && _defectItemList.Count > 0)

  2091.             {

  2092.                 var item = _defectItemList.FirstOrDefault(m => m.Value<string>("code") == code);

  2093.                 if (item == null)

  2094.                     return null;

  2095.                 return item.Value<string>("name");

  2096.             }

  2097.             else

  2098.                 return null;

  2099.         }

  2100.         public string GetDefectName(string modelName, string code)

  2101.         {

  2102.             string labels = modelName.Replace(".trt", ".json");

  2103.             string configPath = confMgr.SysConfigParams.AIModelPath + $"\\{labels}";

  2104.             string lsTmp = File.ReadAllText(configPath);

  2105.             JArray defectItemList = JArray.Parse(lsTmp);

  2106.             if (defectItemList != null && defectItemList.Count > 0)

  2107.             {

  2108.                 var item = defectItemList.FirstOrDefault(m => m.Value<string>("code") == code);

  2109.                 if (item == null)

  2110.                     return null;

  2111.                 return item.Value<string>("name");

  2112.             }

  2113.             else

  2114.                 return null;

  2115.         }

  2116.         public Dictionary<int, string> GetDefectCode()

  2117.         {

  2118.             Dictionary<int, string> dic = new Dictionary<int, string>();

  2119.             for (int i = 0; i < _defectItemList.Count; i++)

  2120.             {

  2121.                 var tt = _defectItemList[i];

  2122.                 dic.Add(tt.Value<int>("id"), tt.Value<string>("code"));

  2123.             }

  2124.             return dic;  

  2125.         }

  2126.         #endregion

  2127. 

  2128.         #region 推理完成处理    

  2129.         private void callBackDefectEvent(DefectTask res)

  2130.         {

  2131.             {

  2132.                 int step = 0;

  2133.                 try

  2134.                 {

  2135.                     Stopwatch stopWatch = new Stopwatch();

  2136.                     stopWatch.Start();

  2137.                     string time = "";

  2138.                     //Log($"检测完成", $"图像队列:{res.record.ScannerPhotoFinishCount + 1}/{res.record.ScannerPhotoCount} (图像{res.photoIndex})检测结果:{res.isSucceed}", WarningEnum.Normal, false);

  2139.                     //string dirPath = FileUtil.initFolder($"{Config.ImagePath}{res.record.BatchId}_{res.record.ReelId}\\");

  2140.                     //string dirSourcePath = FileUtil.initFolder($"{Config.ImagePath}{res.record.BatchId}_{res.record.ReelId}\\源图\\");

  2141.                     //Cv2.Flip(res.bmp, res.bmp, FlipMode.XY);//翻转

  2142. 

  2143.                     //显示打标图片

  2144.                     if (res.excelTable.Rows.Count > 0)

  2145.                         OnAutoRuning(new RunEventArgs(res.bmpTag));

  2146.                     else

  2147.                         OnAutoRuning(new RunEventArgs(res.bmp));

  2148. 

  2149.                     string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.DefectSrcImag.SavePath, new List<string> { $"{ res.record.BarCode}_{ res.record.BarCodeName}" });

  2150.                     if (confMgr.SysConfigParams.DefectSrcImag.AutoSave)//保存所有原图 

  2151.                     {

  2152.                         AddImageSave($"{dirPath}{res.photoIndex}.bmp", res.bmp);

  2153.                         //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save($"{dirPath}{res.photoIndex}.bmp", ImageFormat.Bmp);

  2154.                     }

  2155.                     if (res.isSucceed)

  2156.                     {

  2157.                         step = 1;

  2158.                         Log($"检测完成", $"(图像{res.photoIndex})-瑕疵检测完成，共{res.excelTable.Rows.Count}个瑕疵！各环节用时:{string.Join(",", res.stopwatch)}", WarningEnum.Normal, false);

  2159.                         //AddTextEvent(DateTime.Now,$"打标完成", $"第 ({res.photoIndex}) 张照片，计算过程：{res.resultInfo}");

  2160.                         //if (!Config.IsSaveAllImage && Config.IsSaveDefectSourceImage)

  2161.                         //    OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save($"{dirSourcePath}{res.photoIndex}.bmp", ImageFormat.Bmp);

  2162.                         time += $"(图像{res.photoIndex})";

  2163.                         step = 2;

  2164.                         if (res.excelTable.Rows.Count > 0)

  2165.                         {

  2166.                             res.record.dicPhoto_Defect[res.photoIndex] = true;//改为此图有瑕疵

  2167.                             

  2168.                             step = 3;

  2169.                             res.record.DefectTotalCount += res.excelTable.Rows.Count;

  2170.                             if (res.record.DefectInfoList == null)

  2171.                                 res.record.DefectInfoList = new List<DefectInfo>();

  2172. 

  2173.                             step = 4;

  2174.                             JObject defectNameInfo;

  2175.                             DefectInfo defectInfo = null;

  2176.                             List<object[]> dataRowlist = new List<object[]>();

  2177.                             long preTicks = pStopWatch.ElapsedMilliseconds;// DateTime.Now.Ticks;

  2178.                             for (int i = 0; i < res.lstDefectBmp.Count; i++)

  2179.                             {

  2180.                                 step = 5 + i * 10;

  2181.                                 defectNameInfo = GetDefectLabel(int.Parse(res.excelTable.Rows[i]["类别"].ToString()));

  2182.                                 if(defectNameInfo == null)

  2183.                                 {

  2184.                                     Log($"告警", $"模型标签为空，或未找到标签！", WarningEnum.High);

  2185.                                     continue;

  2186.                                 }

  2187.                                 defectInfo = new DefectInfo

  2188.                                 {

  2189.                                     PhotoIndex = res.photoIndex,

  2190.                                     Code = defectNameInfo.Value<string>("code"),

  2191.                                     Name = defectNameInfo.Value<string>("name"),

  2192.                                     X = double.Parse(res.excelTable.Rows[i]["X"].ToString()),//cm

  2193.                                     Y = Math.Round((res.photoIndex * res.bmp.Height * 1.0d / confMgr.SysConfigParams.Cm2px_y + double.Parse(res.excelTable.Rows[i]["Y"].ToString())), 2),//cm

  2194.                                     Width = double.Parse(res.excelTable.Rows[i]["W"].ToString()),//cm

  2195.                                     Height = double.Parse(res.excelTable.Rows[i]["H"].ToString()),//cm

  2196.                                     ZXD = double.Parse(res.excelTable.Rows[i]["置信度"].ToString()),

  2197.                                     Contrast = double.Parse(res.excelTable.Rows[i]["对比度"].ToString()),

  2198.                                     Target = int.Parse(res.excelTable.Rows[i]["目标"].ToString()),

  2199.                                     image = res.lstDefectBmp[i].Clone(),

  2200.                                     PicY = double.Parse(res.excelTable.Rows[i]["Y"].ToString()),//cm

  2201.                                     CurrDis = res.CurrDis,

  2202.                                 };

  2203.                                 defectInfo.ModifyUserCode = defectInfo.CreateUserCode = res.record.CreateUserCode;

  2204.                                 step = 6 + i * 10;

  2205.                                 

  2206.                                 //判定是否加入二次判断

  2207.                                 if (DefectItemsPuaseNameList.Contains(defectInfo.Name))

  2208.                                 {

  2209.                                     lock (lock_defectPuase)

  2210.                                     {

  2211.                                         defectPuaseList.Add(defectInfo);

  2212.                                     }

  2213.                                     if (!defectPuaseImgList.ContainsKey(res.photoIndex))

  2214.                                         defectPuaseImgList.TryAdd(res.photoIndex, res.bmpTag.Clone());

  2215.                                 }

  2216.                                 //判定是否加入打标

  2217.                                 if (DefectItemsDBNameList.Contains(defectInfo.Name))

  2218.                                 {

  2219.                                     lock (lock_defectDB)

  2220.                                     {

  2221.                                         defectDBList.Add(defectInfo);

  2222.                                     }

  2223.                                 }

  2224. 

  2225.                                 res.record.DefectInfoList.Add(defectInfo);

  2226.                                 defectInfo.uid = preTicks++;// res.record.DefectInfoList.Count;//程序中的唯一索引，用于移除用索引  

  2227.                                 //AddTextEvent(DateTime.Now,$"打标完成", $"第{i}个缺陷：{ JsonConvert.SerializeObject(defectInfo)};  Y={res.photoIndex * res.bmp.Height * 1.0d / Config.cm2px_y}+{res.excelTable.Rows[i]["Y"].ToString()}");

  2228.                                 step = 7 + i * 10;

  2229.                                 //保存打标小图 

  2230.                                 if (confMgr.SysConfigParams.DefectSmallImag.AutoSave)

  2231.                                 {

  2232.                                     dirPath = Util.CreateSubDir(confMgr.SysConfigParams.DefectSmallImag.SavePath, new List<string> { $"{res.record.BarCode}_{res.record.BarCodeName}" });

  2233.                                     string filename = $"{dirPath}{res.photoIndex}_X{defectInfo.X}_Y{defectInfo.Y}_W{defectInfo.Width}_H{defectInfo.Height}_目标{defectInfo.Target}_类别{defectInfo.Code}_置信度{defectInfo.ZXD}.jpg";

  2234.                                     //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.lstDefectBmp[i]).Save(filename, ImageFormat.Jpeg);

  2235.                                     AddImageSave(filename, res.lstDefectBmp[i]);

  2236.                                     defectInfo.TagFilePath = filename;

  2237.                                 }

  2238.                                 step = 8 + i * 10;

  2239. 

  2240.                                 res.lstDefectBmp[i].Dispose();

  2241.                                 dataRowlist.Add(new object[]{ defectInfo.uid,defectInfo.Code,  defectInfo.PhotoIndex,defectInfo.Name,

  2242.                                         defectInfo.CentreX, defectInfo.CentreY / 100,defectInfo.Width * 10,defectInfo.Height * 10, defectInfo.Area * 100, defectInfo.ZXD, defectInfo.Contrast});

  2243. 

  2244.                                 step = 9 + i * 10;

  2245.                                 //告警判断？？？在此还是在收到新照片时触发？？？

  2246.                                 if (res.record.ProductInfo.DefectAreaLimit > 0 && defectInfo.Area >= res.record.ProductInfo.DefectAreaLimit)

  2247.                                 {

  2248.                                     Log($"告警", $"瑕疵面积达到阈值!({defectInfo.Area}>={res.record.ProductInfo.DefectAreaLimit})", WarningEnum.High);

  2249.                                 }

  2250.                                 //必要瑕疵警告

  2251.                                 if (res.record.ProductInfo.DefectAreaLimit > 0 )

  2252.                                 {

  2253.                                     string[] warnlabels =  res.record.ProductInfo.WarnDefect.Split(',');

  2254.                                     var haveLabel = warnlabels.ToList().Find(ft => ft == defectNameInfo.Value<string>("name"));

  2255.                                     if (!string.IsNullOrEmpty(haveLabel))

  2256.                                     {

  2257.                                         Log($"告警", $"出现必须报警瑕疵-{haveLabel}", WarningEnum.High);

  2258.                                     }

  2259.                                 }

  2260.                             }

  2261.                             time += $"->打标小图保存({stopWatch.ElapsedMilliseconds})";

  2262. 

  2263.                             //有瑕疵打标图必需保存 Jpeg

  2264.                             dirPath = Util.CreateSubDir(confMgr.SysConfigParams.DefectSplicImag.SavePath, new List<string> { $"{res.record.BarCode}_{res.record.BarCodeName}" });

  2265.                             if (confMgr.SysConfigParams.DefectSplicImag.AutoSave)//保存瑕疵图 

  2266.                             {

  2267.                                 AddImageSave($"{dirPath}{res.photoIndex}_tag.jpg", res.bmpTag);

  2268.                                 AddImageSave($"{dirPath}{res.photoIndex}_src.bmp", res.bmp);

  2269.                                 //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmpTag).Save($"{dirPath}{res.photoIndex}_tag.jpg", ImageFormat.Jpeg);

  2270.                                 //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save($"{dirPath}{res.photoIndex}_src.bmp", ImageFormat.Bmp);

  2271.                             }

  2272.                             time += $"->瑕疵图保存({stopWatch.ElapsedMilliseconds})";

  2273.                             //Log($"检测完成", "更新UI", WarningEnum.Normal, false);

  2274.                             //更新UI

  2275.                             int bmpHeight = res.bmp.Height;

  2276.                             //显示图片

  2277.                             //OnAutoRuning(new RunEventArgs(defectInfo.image));

  2278.                             //显示瑕疵图

  2279.                             OnAutoRuning(new RunEventArgs(dataRowlist));

  2280. 

  2281.                             step = 9;

  2282.                             //Log($"检测完成", "保存CSV", WarningEnum.Normal, false);

  2283.                             //保存CSV

  2284.                             dirPath = Util.CreateSubDir(confMgr.SysConfigParams.DefectSplicImag.SavePath, new List<string> { $"{res.record.BarCode}_{res.record.BarCodeName}" });

  2285.                             //bool b = Utils.ExcelUtil.DataTable2CSV($"{dirPath}{res.photoIndex}.csv", res.excelTable);

  2286.                             AddImageSave($"{dirPath}{res.photoIndex}.csv", res.excelTable);

  2287.                             //AddTextEvent(DateTime.Now,$"打标完成", $"{res.tag}.xlsx {(b ? "保存成功！" : "保存失败!")}"); 

  2288.                             step = 10;

  2289.                             time += $"->CSV保存({stopWatch.ElapsedMilliseconds})";

  2290.                             //每百米告警判断？？？在此还是在收到新照片时触发？？？

  2291.                             if (res.record.ProductInfo.DefectCountLimit > 0  && res.record.DefectTotalCount >= res.record.ProductInfo.DefectCountLimit)

  2292.                             {

  2293.                                 //每x米判定所有缺陷数量

  2294.                                 if (res.record.ProductInfo.DefectCntLength > 0)

  2295.                                 {

  2296.                                     int compLen = (int)res.record.ProductInfo.DefectCntLength * 100;//每百米 to cm

  2297.                                     int compCount = compLen * confMgr.SysConfigParams.Cm2px_y / res.bmp.Height;

  2298.                                     //从上次告警后重新开始计算长度及数量

  2299.                                     int defectCount = res.record.DefectInfoList.Where(m => m.PhotoIndex >= res.record.preWarningPhotoIndex && m.PhotoIndex >= res.photoIndex + 1 - compCount).Count();

  2300.                                     if (defectCount >= res.record.ProductInfo.DefectCountLimit)

  2301.                                     {

  2302.                                         res.record.preWarningPhotoIndex = res.photoIndex + 1;

  2303.                                         Log($"告警", $"每{Math.Round(res.record.ProductInfo.DefectCntLength, 2)}米瑕疵数量达到阈值!({defectCount}>={res.record.ProductInfo.DefectCountLimit})", WarningEnum.High);

  2304.                                     }

  2305.                                 }

  2306.                                 step = 11;

  2307.                                 //按缺陷计算没X米多少缺陷报警

  2308.                                 for (int i = 0; i < res.record.ProductInfo.QualifiedLimitList.Count; i++)

  2309.                                 {

  2310.                                     var defectWarn = res.record.ProductInfo.QualifiedLimitList[i];

  2311.                                     if (defectWarn.DefectWarnLength > 0 || defectWarn.DefectWarnCnt > 0)

  2312.                                     {

  2313.                                         step = 12;

  2314.                                         int warnLen = defectWarn.DefectWarnLength * 100;//每百米 to cm

  2315.                                         int warnCount = warnLen * confMgr.SysConfigParams.Cm2px_y / res.bmp.Height;

  2316.                                         //从上次告警后重新开始计算长度及数量

  2317.                                         int warnDefectCount = res.record.DefectInfoList.Where(m => m.PhotoIndex >= res.record.preWarningPhotoIndexByLabel[i] && m.PhotoIndex >= res.photoIndex + 1 - warnCount).Count();

  2318.                                         if (warnDefectCount >= defectWarn.DefectWarnCnt)

  2319.                                         {

  2320.                                             res.record.preWarningPhotoIndexByLabel[i] = res.photoIndex + 1;

  2321.                                             Log($"告警", $"每{defectWarn.DefectWarnLength}米{GetDefectName(defectWarn.Code)}瑕疵数量达到阈值!({warnDefectCount}>={defectWarn.DefectWarnCnt})", WarningEnum.High);

  2322.                                         }

  2323.                                     }

  2324.                                 }

  2325.                             }

  2326.                             time += $"->告警判定({stopWatch.ElapsedMilliseconds})";

  2327.                         }

  2328. 

  2329.                     }

  2330.                     else

  2331.                     {

  2332.                         Log($"打标失败", $"(图像{res.photoIndex})-瑕疵检测失败", WarningEnum.Low);

  2333.                     }

  2334.                     

  2335. 

  2336.                     time += $"->完成处理({stopWatch.ElapsedMilliseconds})";

  2337.                     Log($"检测完成2", time, WarningEnum.Normal, false);

  2338.                     res.bmp.Dispose();

  2339.                     res.bmpTag.Dispose();

  2340.                     res.bmps_cut = null;

  2341.                     res.excelTable.Dispose();

  2342.                 }

  2343.                 catch (Exception ex)

  2344.                 {

  2345.                     Log($"打标失败", $"(图像{res.photoIndex})-瑕疵检测异常({step}):{ex.Message}");

  2346.                 }

  2347.                 finally

  2348.                 {

  2349.                     res.record.ScannerPhotoFinishCount++;

  2350.                     int liScannerPhotoFinishCount = res.record.ScannerPhotoFinishCount;

  2351.                     int liScannerPhotoCount = res.record.ScannerPhotoCount;

  2352.                     //Log($"检测完成", $"{liScannerPhotoFinishCount}/{liScannerPhotoCount}", WarningEnum.Normal, false);

  2353.                     //this.BeginInvoke(new System.Action(() =>

  2354.                     //{

  2355.                     //    this.lblWaitImageCount.Text = $"{liScannerPhotoCount - liScannerPhotoFinishCount}"; 

  2356.                     //}));

  2357.                     res = null;

  2358.                     System.GC.Collect();

  2359.                 }

  2360.             }

  2361.         }

  2362.         #endregion

  2363. 

  2364.         #region 图片存储

  2365. 

  2366.         private class SaveImgInfo

  2367.         {

  2368.             public string Path { get; set; }

  2369.             public Mat Img { get; set; }

  2370. 

  2371.             public DataTable DataTable { get; set; }

  2372.         }

  2373. 

  2374.         private ConcurrentQueue<SaveImgInfo> _SaveImgQueue = new ConcurrentQueue<SaveImgInfo>();

  2375. 

  2376.         private void AddImageSave(string path, Mat img)

  2377.         {

  2378.             _SaveImgQueue.Enqueue(new SaveImgInfo { Path = path, Img = img.Clone() });

  2379.             //Thread.Sleep(10);

  2380.             if (_SaveImgQueue.Count > 100)

  2381.             {

  2382.                 SaveImgInfo saveImgInfo;

  2383.                 _SaveImgQueue.TryDequeue(out saveImgInfo);

  2384.                 if (saveImgInfo.Img != null)

  2385.                 {

  2386.                     saveImgInfo.Img.Dispose();

  2387.                     saveImgInfo.Img = null;

  2388.                     System.GC.Collect();

  2389.                 }

  2390.                 Log("存图警告", "存图超限-出队", WarningEnum.Low);

  2391.             }

  2392.         }

  2393.         private void AddImageSave(string path, DataTable dt)

  2394.         {

  2395.             _SaveImgQueue.Enqueue(new SaveImgInfo { Path = path, Img = null, DataTable = dt.Clone() });

  2396.         }

  2397.         /// <summary>

  2398.         /// 图片存储

  2399.         /// </summary>

  2400.         private void SaveImgThreadFunction()

  2401.         {

  2402.             while (true)

  2403.             {

  2404.                 try

  2405.                 {

  2406.                     if (_cts.IsCancellationRequested)

  2407.                         break;

  2408.                     SaveImgInfo saveImgInfo;

  2409.                     if (_SaveImgQueue.TryDequeue(out saveImgInfo))

  2410.                     {

  2411.                         if(saveImgInfo.Img != null)

  2412.                         {

  2413.                             saveImgInfo.Img.ImWrite(saveImgInfo.Path);

  2414.                             //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.lstDefectBmp[i]).Save(filename, ImageFormat.Jpeg);

  2415.                             saveImgInfo.Img.Dispose();

  2416.                             saveImgInfo.Img = null; 

  2417.                         }

  2418.                         else

  2419.                         {

  2420.                             if(!string.IsNullOrEmpty(saveImgInfo.Path))

  2421.                             {

  2422.                                 bool b = Utils.ExcelUtil.DataTable2CSV(saveImgInfo.Path, saveImgInfo.DataTable);

  2423.                             }

  2424.                         }

  2425.                         //System.GC.Collect();

  2426.                     }

  2427.                     #region 堆积显示

  2428.                     OnAutoRuning(new RunEventArgs(0, 0, _SaveImgQueue.Count));

  2429.                     //处理多余

  2430.                     if(_SaveImgQueue.Count > 100)

  2431.                     {

  2432.                         _SaveImgQueue.TryDequeue(out saveImgInfo);

  2433.                         if (saveImgInfo.Img != null)

  2434.                         {

  2435.                             saveImgInfo.Img.Dispose();

  2436.                             saveImgInfo.Img = null;

  2437.                             System.GC.Collect();

  2438.                         }

  2439.                         Log("存图警告", "存图超限-紧急出队", WarningEnum.Low);

  2440.                     }

  2441.                     #endregion

  2442. 

  2443.                     Thread.Sleep(20);

  2444.                 }

  2445.                 catch (Exception e)

  2446.                 {

  2447.                     Log("存图报警", "存图出错：" + e.Message + "\n", WarningEnum.High);

  2448.                 }

  2449.             }

  2450.         }

  2451.     

  2452.         #endregion

  2453. 

  2454.         #region 结束验布

  2455.         public bool Stop()

  2456.         {

  2457.             if (confMgr.SysConfigParams.OpenPLC)

  2458.             {

  2459.                 if (plcDev.IsInit())

  2460.                 {

  2461.                     plcDev.WriteCoil("DB3.DBX0.0", false);//zt

  2462.                     plcDev.WriteCoil("DB3.DBX0.1", true);

  2463.                 }

  2464.                 else

  2465.                 {

  2466.                     Log("运行", "PLC连接异常！", WarningEnum.High);

  2467.                     return false;

  2468.                 }

  2469.             }

  2470.             else if (confMgr.SysConfigParams.OpenIO)

  2471.             {

  2472.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止), GetIOBitIndex((int)DOName.停止), true);

  2473.                 Task.Run(async () =>

  2474.                 {

  2475.                     await Task.Delay(500);

  2476.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止), GetIOBitIndex((int)DOName.停止), false);

  2477.                 });

  2478.             }

  2479.             return true;

  2480.         }

  2481.         public bool DefectEnd(Form fatherFrm)

  2482.         {

  2483.             Log("结束验布", "结束验布！");

  2484.             Stop();

  2485.             Thread.Sleep(500);

  2486.             //CurrentState = CurrentStateEnum.初始;

  2487.             _isRuning = false;

  2488.             _isAuto = false;

  2489.             OnAutoRuning(new RunEventArgs(_isAuto));

  2490.             Thread.Sleep(500);

  2491.             pStopWatch.Stop();

  2492.             pRunSpeedWatch.Stop();

  2493.             if (currKey > 0 )

  2494.             {

  2495.                 if (FrmDialog.ShowDialog(fatherFrm, $"是否保存当前检测结果？", "提示", true) == DialogResult.OK)

  2496.                 {

  2497.                     //Log("验布数据", "等待处理完成！");

  2498.                     //while(_matList1.Count >0 && _matList2.Count>0)

  2499.                     //    Thread.Sleep(200);

  2500.                     //Log("验布数据", "处理完成！");

  2501.                     string szBatchId, szReelId;

  2502.                     double ldErpLen;

  2503.                     //szBatchId = ;

  2504.                     //szReelId = txtReelId.Text.Trim();

  2505.                     //ldErpLen = numErpLen.IsEmpty ? 0 : Convert.ToDouble(numErpLen.Text.Trim());

  2506. 

  2507.                     int myKey = currKey;

  2508.                     //Task.Run(() => { saveCurrRecord(myKey); });

  2509.                     saveCurrRecord(myKey);

  2510.                     //resetUIValue();

  2511.                     currKey = 0;

  2512. 

  2513. 

  2514.                     //this.btnStart.Enabled = true;

  2515.                     //this.btnEnd.Enabled = this.btnPause.Enabled = false;//这里有问题，应该是devPlc回调设置

  2516. 

  2517.                 }

  2518.                 else

  2519.                 {

  2520.                     Log("结束验布", "不保存数据结束验布！");

  2521.                     return false;

  2522.                 }

  2523.             }

  2524.             else

  2525.             {

  2526.                 Log("结束验布", "无数据结束验布！");

  2527.                 _isDefect = false;

  2528.                 return false;

  2529.             }

  2530.             return true;

  2531.         }

  2532.         #endregion

  2533. 

  2534.         #region IO解析

  2535.         private int GetIOPortIndex(int DIDOEnum)

  2536.         {

  2537.             return DIDOEnum / 8;

  2538.         }

  2539.         private int GetIOBitIndex(int DIDOEnum)

  2540.         {

  2541.             return DIDOEnum % 8;

  2542.         }

  2543.         #endregion

  2544. 

  2545.         #region 三色灯

  2546.         /// <summary>

  2547.         /// 三色灯初始化

  2548.         /// </summary>

  2549.         public void LedReady()

  2550.         {

  2551.             if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2552.             {

  2553.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);

  2554.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);

  2555.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);

  2556.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

  2557.             }

  2558.         }

  2559.         /// <summary>

  2560.         /// 运行状态三色灯

  2561.         /// </summary>

  2562.         public void LedRun()

  2563.         {

  2564.             if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2565.             { 

  2566.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), true);

  2567.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);

  2568.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);

  2569.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

  2570.             }

  2571.         }

  2572.         /// <summary>

  2573.         /// 暂停状态三色灯

  2574.         /// </summary>

  2575.         public void LedPause()

  2576.         {

  2577.             if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2578.             {

  2579.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);

  2580.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);

  2581.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);

  2582.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

  2583.             }

  2584.         }

  2585.         //控制黄灯闪烁

  2586.         private bool Blink;

  2587.         private int BlinkCnt = 0;

  2588.         //控制蜂鸣间隔

  2589.         private int BuzzCnt = 0;

  2590.         /// <summary>

  2591.         /// 回原状态三色灯

  2592.         /// </summary>

  2593.         /// <param name="val"></param>

  2594.         public void LedRset(bool val)

  2595.         {

  2596.             if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2597.             { 

  2598.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);

  2599.                 //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), val);

  2600.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);

  2601.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

  2602. 

  2603.                 Blink = val;

  2604.                 BlinkCnt = 0;

  2605.             }

  2606.         }

  2607.         #endregion

  2608. 

  2609.         #region 报警等、按钮IO

  2610.         /// <summary>

  2611.         /// 三色灯报警状态显示

  2612.         /// </summary>

  2613.         /// <returns></returns>

  2614.         public bool WarningShowLed(bool DisEnableBuzz)

  2615.         {

  2616.             bool sts = false;

  2617.             if (statusMgr.Warning == WarningEnum.Normal)

  2618.             {

  2619.                 if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2620.                 {

  2621.                     if (statusMgr.Status == SystemStsEnum.Auto)

  2622.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), true);

  2623.                     else

  2624.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);

  2625.                     if (statusMgr.Status == SystemStsEnum.Pause)

  2626.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);

  2627.                     else

  2628.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);

  2629.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

  2630.                     BuzzCnt = 0;

  2631.                     //判断黄灯是否需要闪烁，调用200ms一次

  2632.                     if (Blink)

  2633.                     {

  2634.                         if (BlinkCnt < 3)

  2635.                             ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), true);

  2636.                         else if (BlinkCnt < 6)

  2637.                             ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);

  2638.                         BlinkCnt++;

  2639.                         if (BlinkCnt == 6)

  2640.                             BlinkCnt = 0;

  2641.                     }

  2642.                     else

  2643.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);

  2644.                 }

  2645.             }

  2646.             if (statusMgr.Warning == WarningEnum.Low)

  2647.             {

  2648.                 //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);

  2649.                 //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), true);

  2650.                 if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2651.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);

  2652.                 //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);

  2653.                 //sts = true;

  2654.             }

  2655.             if (statusMgr.Warning == WarningEnum.High)

  2656.             {

  2657.                 //发送停止信号

  2658.                 Stop();

  2659.                 sts = true;

  2660.                 if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2661.                 { 

  2662.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);

  2663.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);

  2664.                     if (confMgr.SysConfigParams.OpenBuzzer && !DisEnableBuzz)

  2665.                     {

  2666.                         if (BuzzCnt < 3)

  2667.                             ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), true);

  2668.                         else if (BuzzCnt < 6)

  2669.                             ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

  2670.                         BuzzCnt++;

  2671.                         if (BuzzCnt == 6)

  2672.                             BuzzCnt = 0;

  2673.                     }

  2674.                 }

  2675.             }

  2676.             return sts;

  2677.         }

  2678.         /// <summary>

  2679.         /// 按钮IO检测

  2680.         /// </summary>

  2681.         /// <returns></returns>

  2682.         public int ButtonIOTrg(bool DisEnableDoorAlm)

  2683.         {

  2684.             int ret = 0;

  2685.             bool sts;

  2686.             if (confMgr.SysConfigParams.OpenIO && _isOpenIO)

  2687.             {

  2688.                 //if (confMgr.SysConfigParams.OpenDoor && !DisEnableDoorAlm)

  2689.                 //{

  2690.                 //    ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.门磁), GetIOBitIndex((int)DIName.门磁), out sts);

  2691.                 //    if ((!sts) && (statusMgr.Status == SystemStsEnum.Auto))

  2692.                 //    {

  2693.                 //        Log("暂停", "门磁报警-门打开", WarningEnum.Low);

  2694.                 //        statusMgr.GotoPause();

  2695.                 //        SendStatus();

  2696.                 //        ret = 2;

  2697.                 //    }

  2698.                 //}

  2699.                 ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.暂停按钮), GetIOBitIndex((int)DIName.暂停按钮), out sts);

  2700.                 if (sts)

  2701.                 {

  2702.                     Log("暂停", "手动暂停");

  2703.                     statusMgr.GotoPause();

  2704.                     SendStatus();

  2705.                     ret = 2;

  2706.                 }

  2707.                 ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.复位按钮), GetIOBitIndex((int)DIName.复位按钮), out sts);

  2708.                 if (sts)

  2709.                 {

  2710.                     ret = 3;

  2711. 

  2712.                 }

  2713.                 ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.启动按钮), GetIOBitIndex((int)DIName.启动按钮), out sts);

  2714.                 if (sts)

  2715.                     ret = 1;

  2716.             }

  2717.             return ret;

  2718.         }

  2719.         #endregion

  2720. 

  2721.         #region 系统关闭

  2722.         /// <summary>

  2723.         /// 关闭

  2724.         /// </summary>

  2725.         public void Close()

  2726.         {

  2727.             _isInit = false;

  2728.             _isRuning = false;

  2729.             if (null != _cts)

  2730.             {

  2731.                 _cts.Cancel();

  2732.             }

  2733.             if (null != _mainThread)

  2734.             {

  2735.                 _mainThread.Join(1000);

  2736.             }

  2737.             if (null != _Cam1Thread)

  2738.             {

  2739.                 _Cam1Thread.Join(1000);

  2740.             }

  2741.             if (null != _Cam2Thread)

  2742.             {

  2743.                 _Cam2Thread.Join(1000);

  2744.             }

  2745.             if (null != _SpeedThread)

  2746.             {

  2747.                 _SpeedThread.Join(1000);

  2748.             }

  2749. 

  2750.             if (null != _SaveImgThread)

  2751.             {

  2752.                 _SaveImgThread.Join(1000);

  2753.             }

  2754. 

  2755.             //关闭计米器

  2756.             if (confMgr.SysConfigParams.OpenLengthCount)

  2757.                 lengthCounter.Close();

  2758. 

  2759.             //关闭相机

  2760.             LineCamDev1.CloseCamera();

  2761.             LineCamDev2.CloseCamera();

  2762. 

  2763.             //关闭光源

  2764.             for (int i = 0; i < LightChCount; i++)

  2765.             {

  2766.                 lightDev.CloseLight(i + 1);

  2767.             }

  2768. 

  2769.             lightDev.CloseDev();

  2770. 

  2771. 

  2772.             //关闭io

  2773.             if (confMgr.SysConfigParams.OpenIO)

  2774.             {

  2775.                 ioCardDev.ResetAllDO();

  2776. 

  2777.                 ioCardDev.CloseBoard();

  2778.             }

  2779. 

  2780.             if (confMgr.SysConfigParams.OpenPLC)

  2781.                 plcDev.CloseDev();

  2782. 

  2783.         }

  2784.         #endregion

  2785. 

  2786.         #region 日志报警

  2787.         /// <summary>

  2788.         /// 初始化记录报警和显示

  2789.         /// </summary>

  2790.         /// <param name="tag">标头</param>

  2791.         /// <param name="msg">内容</param>

  2792.         /// <param name="warning">报警状态</param>

  2793.         private void InitLog(string msg, string tag = "初始化", WarningEnum warning = WarningEnum.Normal)

  2794.         {

  2795.             OnInitRuning(new InitEventArgs(msg));

  2796.             statusMgr.GotoWarning(warning, tag, msg);

  2797.         }

  2798.         /// <summary>

  2799.         /// 记录报警和显示

  2800.         /// </summary>

  2801.         /// <param name="tag">标头</param>

  2802.         /// <param name="msg">内容</param>

  2803.         /// <param name="warning">报警状态</param>

  2804.         private void Log(string tag, string msg, WarningEnum warning = WarningEnum.Normal, bool show = true)

  2805.         {

  2806.             if(show)

  2807.                 OnMainRuning(new MainEventArgs(tag, msg, warning));

  2808.             statusMgr.GotoWarning(warning, tag, msg);

  2809.             //开启云端

  2810.             if ((init_Cloud) && (warning != WarningEnum.Normal))

  2811.             {

  2812.                 //上传报警状态和信息

  2813.                 string statusStr = warning == WarningEnum.Normal ? "正常" : warning == WarningEnum.Low ? "警告" : "系统报警";

  2814.                 cloudMgr.SendTopic("device/attributes", $"{{\"status\": \"{statusStr}\",  \"alm\": \"{tag}-{msg}\", " +

  2815.                 $"\"name\": \"{confMgr.SysConfigParams.CloudThisName}\", \"DailyOutput\": \"{DailyOutput}\"}}");

  2816.             }

  2817.         }

  2818.         #endregion

  2819. 

  2820.         #region 硬件 

  2821. 

  2822.         #region 硬件型号配置

  2823.         public LightDevNameEnum SysUseLight = LightDevNameEnum.CST;

  2824.         #endregion

  2825. 

  2826.         #region 硬件字段

  2827.         private CamDev _LinecamDev1;

  2828.         /// <summary>

  2829.         /// io控制卡

  2830.         /// </summary>

  2831.         public CamDev LineCamDev1 { get { return _LinecamDev1; } }

  2832.         private CamDev _LinecamDev2;

  2833.         /// <summary>

  2834.         /// io控制卡

  2835.         /// </summary>

  2836.         public CamDev LineCamDev2 { get { return _LinecamDev2; } }

  2837. 

  2838.         private IOCardDev ioCardDev;

  2839.         /// <summary>

  2840.         /// io控制卡

  2841.         /// </summary>

  2842.         public IOCardDev IOCardDev { get { return ioCardDev; } }

  2843. 

  2844.         private LightDev lightDev;

  2845.         /// <summary>

  2846.         /// 光源控制

  2847.         /// </summary>

  2848.         public LightDev LightDev { get { return lightDev; } }

  2849.         public string LightName { get { return "Light"; } }

  2850.         public int LightChCount = 1;//美尚4通道，其他6通道

  2851. 

  2852.         /// <summary>

  2853.         /// 计米器

  2854.         /// </summary>

  2855.         public SerialPort LengthCounterPort { get { return lengthCounter; } }

  2856.         private SerialPort lengthCounter;

  2857. 

  2858.         private PlcDev plcDev;

  2859.         /// <summary>

  2860.         /// PLC控制

  2861.         /// </summary>

  2862.         public PlcDev PlcDev { get { return plcDev; } }

  2863. 

  2864.         private PrintControl printControl;

  2865.         /// <summary>

  2866.         /// 打印机模块

  2867.         /// </summary>

  2868.         public PrintControl PrintControl { get { return printControl; } }

  2869.         #endregion

  2870. 

  2871.         #region 初始化和基本电机IO操作

  2872.         private void InitDev()

  2873.         { 

  2874.             ioCardDev = new AdvantechIO();

  2875. 

  2876.             //CpuType.S71200 = 30

  2877.             plcDev = new PlcDev(CpuType.S71200, confMgr.SysConfigParams.PLC_IP, (short)confMgr.SysConfigParams.PLC_Rack, (short)confMgr.SysConfigParams.PLC_Solt);

  2878. 

  2879.             _LinecamDev1 = new CamDev(CameraEnumType.IKap, confMgr.SysConfigParams.CamIndex_1.ToString(), confMgr.SysConfigParams.CamPath_1, confMgr.SysConfigParams.CamDev_1);

  2880.             _LinecamDev2 = new CamDev(CameraEnumType.IKap, confMgr.SysConfigParams.CamIndex_2.ToString(), confMgr.SysConfigParams.CamPath_2, confMgr.SysConfigParams.CamDev_2);

  2881. 

  2882.             if (SysUseLight == LightDevNameEnum.CST)

  2883.                 lightDev = new CSTLight(LightName, LightChCount);

  2884.             else

  2885.                 lightDev = new RseeLight(SysUseLight, LightName);

  2886. 

  2887.             lengthCounter = new SerialPort(confMgr.SysConfigParams.LengthCounterCom, confMgr.SysConfigParams.LengthCounterComBaud);

  2888.         }

  2889.         /// <summary>

  2890.         /// 初始化硬件

  2891.         /// </summary>

  2892.         /// <returns></returns>

  2893.         private bool InitAllDev()

  2894.         {

  2895.             bool ret = false;

  2896.             InitDev();

  2897. #if Online

  2898.             //打印机模块初始化

  2899.             //InitLog("打印机模块初始化...");

  2900.             //try

  2901.             //{

  2902.             //    printControl = new PrintControl();

  2903.             //    InitLog("初始化打印机模块成功！");

  2904.             //}

  2905.             //catch (Exception ex)

  2906.             //{

  2907.             //    printControl = null;

  2908.             //    InitLog($"初始化打印机模块失败！ {ex.Message}");

  2909.             //}

  2910.             if (confMgr.SysConfigParams.OpenLengthCount)

  2911.             {

  2912.                 lengthCounter.Open();

  2913.                 if (!lengthCounter.IsOpen)

  2914.                 {

  2915.                     InitLog("计米器初始化失败！", "初始化", WarningEnum.High);

  2916.                     return ret;

  2917.                 }

  2918.                 InitLog("计米器初始化成功！");

  2919.             }

  2920.             if (confMgr.SysConfigParams.OpenPLC)

  2921.             {

  2922.                 //PLC初始化

  2923.                 InitLog("PLC连接初始化...");

  2924.                 if(!plcDev.OpenDev())

  2925.                 {

  2926.                     InitLog("PLC连接初始化失败！", "初始化", WarningEnum.High);

  2927.                     return ret;

  2928.                 }

  2929.                 InitLog("PLC连接成功！");

  2930.             }

  2931.             _isOpenIO = false;

  2932.             if (confMgr.SysConfigParams.OpenIO)

  2933.             {

  2934.                 //IO初始化

  2935.                 InitLog("IO板卡初始化...");

  2936.                 if (ioCardDev.InitBoard(MaiMuControl.Device.IOBordType.Advantech) < 0)

  2937.                 {

  2938.                     InitLog("IO板卡初始化失败！", "初始化", WarningEnum.High);

  2939.                     return ret;

  2940.                 }

  2941.                 if (ioCardDev.OpenBoard(confMgr.SysConfigParams.IODevName, confMgr.SysConfigParams.IOCfgPath) < 0)

  2942.                 {

  2943.                     InitLog("打开IO板卡失败！", "初始化", WarningEnum.High);

  2944.                     return ret;

  2945.                 }

  2946.                 if (ioCardDev.ResetAllDO() < 0)

  2947.                 {

  2948.                     InitLog("IO Reset失败！", "初始化", WarningEnum.High);

  2949.                     return ret;

  2950.                 }

  2951.                 _isOpenIO = true;

  2952.                 InitLog("初始化IO板卡成功！");

  2953.             }

  2954. 

  2955.             //相机初始化

  2956.             if(!_LinecamDev1.InitCamera())

  2957.             {

  2958.                 InitLog("相机1初始化失败！", "初始化", WarningEnum.High);

  2959.                 return ret;

  2960.             }

  2961.             if(!_LinecamDev1.OpenCamera())

  2962.             {

  2963.                 InitLog("相机1打开失败！", "初始化", WarningEnum.High);

  2964.                 return ret;

  2965.             }

  2966.             _LinecamDev1.IsMirrorX = confMgr.SysConfigParams.Cam1_flipX;

  2967.             _LinecamDev1.IsMirrorY = confMgr.SysConfigParams.Cam1_flipY;

  2968.             _LinecamDev1.WarningEvent = (level, msg) =>

  2969.              {

  2970.                  Log($"相机1设备事件", msg, level);

  2971.              };

  2972. 

  2973.             if (!_LinecamDev2.InitCamera())

  2974.             {

  2975.                 InitLog("相机2初始化失败！", "初始化", WarningEnum.High);

  2976.                 return ret;

  2977.             }

  2978.             if (!_LinecamDev2.OpenCamera())

  2979.             {

  2980.                 InitLog("相机2打开失败！", "初始化", WarningEnum.High);

  2981.                 return ret;

  2982.             }

  2983.             _LinecamDev2.IsMirrorX = confMgr.SysConfigParams.Cam2_flipX;

  2984.             _LinecamDev2.IsMirrorY = confMgr.SysConfigParams.Cam2_flipY;

  2985.             _LinecamDev2.WarningEvent = (level, msg) =>

  2986.             {

  2987.                 Log($"相机2设备事件", msg, level);

  2988.             };

  2989.             //光源初始化

  2990.             InitLog("光源控制器初始化...");

  2991.             int com_num = int.Parse(confMgr.SysConfigParams.LightCom.Remove(0, 3));

  2992.             if (lightDev.InitDev(com_num, confMgr.SysConfigParams.LightComBaud) < 0)

  2993.             {

  2994.                 InitLog("光源控制器初始化失败！", "初始化", WarningEnum.High);

  2995.                 return ret;

  2996.             }

  2997.             InitLog("初始化光源控制器成功！");

  2998.             //关闭光源

  2999.             for (int i = 0; i < LightChCount; i++)

  3000.             {

  3001.                 lightDev.CloseLight(i + 1);

  3002.             }

  3003. #endif

  3004.             ret = true;

  3005.             return ret;

  3006.         }

  3007.         /// <summary>

  3008.         /// 读取硬件配置

  3009.         /// </summary>

  3010.         private bool LoadDevConfig()

  3011.         {

  3012.             LightParams lightParams = new LightParams(LightName, LightChCount);

  3013.             //LightChCount = 6;

  3014.             //lightParams.DevName = LightName;

  3015.             lightParams.ComName = confMgr.SysConfigParams.LightCom;

  3016.             lightParams.Buad = confMgr.SysConfigParams.LightComBaud;

  3017.             //lightParams.ChCount = LightChCount;

  3018.             lightDev.WriteCfgInfo(confMgr.DevConfigPath, lightParams);

  3019.             return true;

  3020.         }

  3021. 

  3022. #endregion

  3023. #endregion

  3024. 

  3025.         #region 硬盘检测

  3026.         public static bool CheckDisk(IWin32Window owner, int max = 10)

  3027.         {

  3028.             if (!string.IsNullOrEmpty(ConfMgr.Instance.SysConfigParams.DefectSrcImag.SavePath))

  3029.             { 

  3030.                 string path = ConfMgr.Instance.SysConfigParams.DefectSrcImag.SavePath;

  3031.                 string volume = path.Substring(0, path.IndexOf(':'));

  3032.                 long freespace = DiskAPI.GetHardDiskSpace(volume);

  3033.                 if (freespace < max)

  3034.                 {

  3035.                     string tip = $"当前{volume}硬盘容量：{freespace}GB，小于{max}GB。注意清理！！";

  3036.                     FrmDialog.ShowDialog(owner, tip, "警告", true);

  3037.                     return false;

  3038.                 }

  3039.             }

  3040.             return true;

  3041.         }

  3042.         #endregion

  3043. 

  3044.         #region 初始化事件

  3045.         /// <summary>

  3046.         /// 初始化回调

  3047.         /// </summary>

  3048.         /// <param name="sender"></param>

  3049.         /// <param name="e"></param>

  3050.         public delegate void InitEventHandler(Object sender, InitEventArgs e);

  3051.         public event InitEventHandler InitRuning;

  3052.         protected virtual void OnInitRuning(InitEventArgs e)

  3053.         {

  3054.             if (null != InitRuning)

  3055.             {

  3056.                 InitRuning(this, e);

  3057.             }

  3058.         }

  3059.         #endregion

  3060. 

  3061.         #region 主窗体显示事件

  3062.         /// <summary>

  3063.         /// 主窗体回调

  3064.         /// </summary>

  3065.         /// <param name="sender"></param>

  3066.         /// <param name="e"></param>

  3067.         public delegate void MainEventHandler(Object sender, MainEventArgs e);

  3068.         public event MainEventHandler MainRuning;

  3069.         protected virtual void OnMainRuning(MainEventArgs e)

  3070.         {

  3071.             if (null != MainRuning)

  3072.             {

  3073.                 MainRuning(this, e);

  3074.             }

  3075.         }

  3076. 

  3077.         /// <summary>

  3078.         /// 流程回调

  3079.         /// </summary>

  3080.         /// <param name="sender"></param>

  3081.         /// <param name="e"></param>

  3082.         public delegate void RunEventHandler(Object sender, RunEventArgs e);

  3083.         public event RunEventHandler AutoRuning;

  3084.         protected virtual void OnAutoRuning(RunEventArgs e)

  3085.         {

  3086.             if (null != AutoRuning)

  3087.             {

  3088.                 AutoRuning(this, e);

  3089.             }

  3090.         }

  3091.         #endregion

  3092. 

  3093.         #region 加载测试列表

  3094.         /// <summary>

  3095.         /// 加载产品列表

  3096.         /// </summary>

  3097.         public void LoadProductCodeList()

  3098.         {

  3099.             try

  3100.             {

  3101.                 productCodeList = PdtService.GetListNav().Select(m => m.Name).ToList();

  3102.                 productIdList = PdtService.GetListNav().Select(m => m.Id).ToList();

  3103.             }

  3104.             catch (Exception ex)

  3105.             {

  3106.                 OnMainRuning(new MainEventArgs("启动", "加载检测标准失败:" + ex.Message, WarningEnum.High));

  3107.                 statusMgr.GotoWarning(WarningEnum.High, "启动", "加载检测标准失败:" + ex.Message);

  3108.                 SendStatus();

  3109.             }

  3110.         }

  3111.         #endregion

  3112. 

  3113.         #region 界面显示

  3114.         public static void showRowNum_onDataGrid_RowPostPaint(DataGridView dgv, object sender, DataGridViewRowPostPaintEventArgs e)

  3115.         {

  3116.             Rectangle rectangle = new Rectangle(e.RowBounds.Location.X, e.RowBounds.Location.Y, dgv.RowHeadersWidth - 4, e.RowBounds.Height);

  3117.             TextRenderer.DrawText(e.Graphics, (e.RowIndex + 1).ToString(), dgv.RowHeadersDefaultCellStyle.Font, rectangle, dgv.RowHeadersDefaultCellStyle.ForeColor, TextFormatFlags.VerticalCenter | TextFormatFlags.Right);

  3118.         }

  3119.         /// <summary>

  3120.         /// IO二进制数据格式化到8位 XXXX10X0

  3121.         /// </summary>

  3122.         /// <param name="datas"></param>

  3123.         /// <returns></returns>

  3124.         public static string[] IODataFormatBinaryStr(string[] datas, bool clone, char defaultPadChar = 'X')

  3125.         {

  3126.             string[] datas2 = new string[datas.Length];

  3127.             for (int i = 0; i < datas.Length; i++)

  3128.             {

  3129.                 if (clone)

  3130.                 {

  3131.                     datas2[i] = datas[i].Replace(" ", "");

  3132.                     if (datas2[i].Length > 8)

  3133.                         datas2[i] = datas2[i].Substring(datas2[i].Length - 8);

  3134.                     else if (datas2[i].Length < 8)

  3135.                         datas2[i] = datas2[i].PadLeft(8, defaultPadChar);

  3136.                 }

  3137.                 else

  3138.                 {

  3139.                     datas[i] = datas[i].Replace(" ", "");

  3140.                     if (datas[i].Length > 8)

  3141.                         datas[i] = datas[i].Substring(datas[i].Length - 8);

  3142.                     else if (datas[i].Length < 8)

  3143.                         datas[i] = datas[i].PadLeft(8, defaultPadChar);

  3144. 

  3145.                     datas2 = datas;

  3146.                 }

  3147.             }

  3148. 

  3149.             return datas2;

  3150.         }

  3151.         /// <summary>

  3152.         /// 

  3153.         /// </summary>

  3154.         /// <param name="op_show_list">[XXHL XXXX,XXXX XXXX,...]</param>

  3155.         /// <param name="currIoDatas">[byte,byte,byte,byte]</param>

  3156.         /// <returns></returns>

  3157.         public static bool compareIOInput(string[] op_show_list, byte[] currIoDatas)

  3158.         {

  3159.             int isok = 0;//1-true 2-false

  3160.             string IN_OP_SHOW;

  3161.             for (int i = 0; i < currIoDatas.Length; i++)

  3162.             {

  3163.                 IN_OP_SHOW = op_show_list[i].Replace(" ", "").PadLeft(8, 'X');

  3164.                 if (IN_OP_SHOW.IndexOf('H') < 0 && IN_OP_SHOW.IndexOf('L') < 0)

  3165.                     continue;

  3166. 

  3167.                 for (int j = 7; j >= 0; j--)

  3168.                 {

  3169.                     byte bit = (byte)(1 << 7 - j);

  3170.                     if (IN_OP_SHOW[j] == 'H')

  3171.                     {

  3172.                         if ((bit & currIoDatas[i]) > 0)

  3173.                             isok = 1;

  3174.                         else

  3175.                         {

  3176.                             isok = 2;

  3177.                             break;

  3178.                         }

  3179.                     }

  3180.                     else if (IN_OP_SHOW[j] == 'L')

  3181.                     {

  3182.                         if ((currIoDatas[i] ^ (currIoDatas[i] | bit)) > 0)

  3183.                             isok = 1;

  3184.                         else

  3185.                         {

  3186.                             isok = 2;

  3187.                             break;

  3188.                         }

  3189.                     }

  3190.                 }

  3191. 

  3192.                 //已经不符

  3193.                 if (isok == 2) break;

  3194.             }

  3195. 

  3196.             //

  3197.             return isok == 1;

  3198.         }

  3199. 

  3200.         #endregion

  3201. 

  3202.         #region 启动

  3203.         public bool StartMotion()

  3204.         {

  3205.             if (confMgr.SysConfigParams.OpenAutoRun)

  3206.             {

  3207.                 Log("启动", "下发启动指令...");

  3208.                 if (confMgr.SysConfigParams.OpenPLC)

  3209.                 {

  3210.                     if (plcDev.IsInit())

  3211.                     {

  3212.                         plcDev.WriteCoil("DB3.DBX0.1", false);

  3213.                         plcDev.WriteCoil("DB3.DBX0.0", true);//启动

  3214.                     }

  3215.                     else

  3216.                     {

  3217.                         Log("运行", "PLC连接异常！", WarningEnum.High);

  3218.                         return false;

  3219.                     }

  3220.                 }

  3221.                 else if (confMgr.SysConfigParams.OpenIO)

  3222.                 {

  3223.                     bool sts;

  3224.                     ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.暂停按钮), GetIOBitIndex((int)DIName.暂停按钮), out sts);

  3225.                     if (!sts)

  3226.                     {

  3227.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动), GetIOBitIndex((int)DOName.启动), true);

  3228.                         Task.Run(async () =>

  3229.                         {

  3230.                             await Task.Delay(500);

  3231.                             ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动), GetIOBitIndex((int)DOName.启动), false);

  3232.                         });

  3233.                     }

  3234.                     else

  3235.                         Log("运行", "存在暂停信号！", WarningEnum.Low);

  3236.                 }

  3237.             }

  3238.             else

  3239.                 Log("启动", "检测流程开启...");

  3240.             return true;

  3241.         }

  3242.         /// <summary>

  3243.         /// 加载ERP数据库数据

  3244.         /// </summary>

  3245.         /// <param name="barCode"></param>

  3246.         /// <returns></returns>

  3247.         private DataRow loadErpData(string barCode)

  3248.         {

  3249.             var paramList = new List<SugarParameter>() {

  3250.                         new SugarParameter("@code", barCode)

  3251.                     };

  3252.             Stopwatch stopwatch = Stopwatch.StartNew();

  3253.             var data = confMgr.execSql(confMgr.SysConfigParams.ErpSql, paramList);

  3254.             if (data != null && data.Rows.Count < 1)

  3255.             {

  3256.                 Log("Erp查询结果", $"{barCode}: 时长={stopwatch.ElapsedMilliseconds}ms, 无数据！", WarningEnum.Normal);

  3257.                 return null;

  3258.             }

  3259. 

  3260.             Log("Erp查询结果", $"{barCode}: 时长={stopwatch.ElapsedMilliseconds}ms, {JsonConvert.SerializeObject(data.Rows[0])}", WarningEnum.Normal);

  3261.             return data.Rows[0];

  3262.         }

  3263.         /// <summary>

  3264.         /// 自动运行

  3265.         /// </summary>

  3266.         /// <returns></returns>

  3267.         public bool StartRun(Form fatherFrm, string sn, ref string DefectName, ref string name, ref string batch, ref string reel, ref string cnt)

  3268.         {

  3269.             bool ret = true;

  3270.             _FatherFrm = fatherFrm;

  3271.             string barCodeName = "", len = "0", batchId = "", reelId = "";

  3272.             if(string.IsNullOrEmpty(name))

  3273.                 name = "未找到";

  3274.             //运行前清除过期图片文件

  3275.             //DateTime st = DateTime.Now;

  3276.             DelectPictureFile();

  3277.             if ((statusMgr.Status != SystemStsEnum.Standby) && (statusMgr.Status != SystemStsEnum.Pause))

  3278.             {

  3279.                 Log("运行", "系统非可运行状态", WarningEnum.Low);

  3280.                 return false;

  3281.             }

  3282. 

  3283.             if (string.IsNullOrEmpty(sn))

  3284.             {

  3285.                 Log("运行", "产品条码为空！", WarningEnum.Low);

  3286.                 return false;

  3287.             }

  3288.       

  3289.             //禾欣数据 sn，长度数量， 批号， 卷号

  3290.             if (!string.IsNullOrWhiteSpace(confMgr.SysConfigParams.ErpDBConStr) && !string.IsNullOrWhiteSpace(confMgr.SysConfigParams.ErpSql) && !string.IsNullOrWhiteSpace(sn))

  3291.             {

  3292.                 Log("扫码", $"产品条码({sn})到ERP查询对应数据...", WarningEnum.Normal);

  3293.                 var rowData = this.loadErpData(sn);

  3294.                 if (rowData == null)

  3295.                 {

  3296.                     Log("扫码", $"产品条码({sn})无对应ERP数据，不做响应！", WarningEnum.High);

  3297.                     return false;

  3298.                 }

  3299. 

  3300.                 barCodeName = rowData[0].ToString();

  3301.                 if (rowData.ItemArray.Length > 1) len = rowData[1].ToString();

  3302.                 if (rowData.ItemArray.Length > 2) batchId = rowData[2].ToString();

  3303.                 if (rowData.ItemArray.Length > 3) reelId = rowData[3].ToString();

  3304.             }

  3305.             else

  3306.                 barCodeName = sn;//没有ERP对应关系时直接使用条码做为品名

  3307. 

  3308.             //Log("调试", $"time1:{(DateTime.Now - st).Milliseconds}");

  3309.             //st = DateTime.Now;

  3310.             int errStep = 0;

  3311.             try

  3312.             {

  3313.                 Product model;

  3314.                 //禾欣客户使用

  3315.                 if(confMgr.SysConfigParams.CustomerName == "hexin")

  3316.                 {

  3317.                     errStep = 1;

  3318.                     //SHNY-PX-6-***

  3319.                     string[] codes = barCodeName.Split(new char[] { '-' });

  3320.                     if (codes.Length < 4)

  3321.                     {

  3322.                         Log("扫码", $"产品品名({barCodeName})格式错误，不做响应！", WarningEnum.Low);

  3323.                         return false;

  3324.                     }

  3325.                     errStep = 2;

  3326.                     //加载新产品  

  3327.                     string pcode = "1-" + codes[2];

  3328.                     if (codes[1] == "0" || confMgr.SysConfigParams.SuedeList.Contains(codes[1]))

  3329.                         pcode = "0-" + codes[2];

  3330.                     model = PdtService.GetModelNav(pcode); //frmProduct.loadProduct(code);

  3331. 

  3332.                     name = barCodeName;

  3333.                     batch = batchId;

  3334.                     reel = reelId;

  3335.                     cnt = len;

  3336.                 }

  3337.                 else

  3338.                 {

  3339.                     if (string.IsNullOrEmpty(name) || name == "未找到")

  3340.                     {

  3341.                         Log("运行", "产品品名为空！", WarningEnum.Low);

  3342.                         return false;

  3343.                     }

  3344.                     if (string.IsNullOrEmpty(DefectName))

  3345.                     {

  3346.                         Log("运行", "检测标准未选择！", WarningEnum.Low);

  3347.                         return false;

  3348.                     }

  3349.                     //if (string.IsNullOrEmpty(batch))

  3350.                     //{

  3351.                     //    Log("运行", "批号为空！", WarningEnum.Low);

  3352.                     //    return false;

  3353.                     //}

  3354.                     //if (string.IsNullOrEmpty(reel))

  3355.                     //{

  3356.                     //    Log("运行", "卷号为空！", WarningEnum.Low);

  3357.                     //    return false;

  3358.                     //}

  3359.                     barCodeName = name;

  3360.                     batchId = batch;

  3361.                     reelId = reel;

  3362.                     double t;

  3363.                     cnt = double.TryParse(cnt, out t) ?cnt:"0";

  3364.                     model = PdtService.GetModelNavByName(DefectName);

  3365.                 }

  3366.                 if (model == null)

  3367.                 {

  3368.                     Log("扫码", $"编码({sn})对应配方不存在，请先添加产品配方设置，暂停设备！", WarningEnum.High);

  3369.                     return false;

  3370.                 }

  3371.                 DefectName = model.Name;

  3372. 

  3373.                 //数据处理

  3374.                 Records record;

  3375.                 lock (lockCurrKey)

  3376.                 {

  3377.                     errStep = 3;

  3378.                     //保存，这里队列图片可能还未检测完 

  3379.                     if (currKey > 0)

  3380.                     {

  3381.                         string szBatchId, szReelId;

  3382.                         double ldErpLen;

  3383.                         szBatchId = batch;

  3384.                         szReelId = reel;

  3385.                         ldErpLen = Convert.ToDouble(cnt);

  3386.                         //BatchId = code,//code[2]

  3387.                         //ReelId = "1",//code[3]

  3388.                         int mykey = currKey;

  3389.                         //Task.Run(() => { saveCurrRecord(mykey); });

  3390.                         saveCurrRecord(mykey);

  3391.                         currKey = 0;

  3392.                     }

  3393. 

  3394.                     errStep = 4;

  3395.                     var now = DateTime.Now;

  3396.                     currKey = now.Hour * 10000 + now.Minute * 100 + now.Second;

  3397.                     //var materialItem =  codes[0]+"-"+ codes[1];

  3398.                     //var colorItem = Config.getColorItem(int.Parse(codes[2]));

  3399.                     record = new Records()

  3400.                     {

  3401.                         currKey = currKey,

  3402.                         ProductId = model.Id,

  3403.                         ProductInfo = model,//后面计算合格时用

  3404.                         Color = model.ColorName,

  3405.                         Material = model.Material,//codes[0] + "-" + codes[1],// (materialItem == null ? "未知" : materialItem["name"].ToString()), 

  3406.                         BarCode = sn,

  3407.                         BarCodeName = barCodeName,

  3408.                         ErpLen = double.Parse(len),

  3409.                         BatchId = batchId,

  3410.                         ReelId = reelId,

  3411.                         ModifyUserCode = userMgr.LoginUser.Code,

  3412.                         CreateUserCode = userMgr.LoginUser.Code,

  3413.                     };

  3414.                     htTask.Add(currKey, record);

  3415.                 }

  3416.                 errStep = 8;

  3417.                 // 

  3418.                 errStep = 9;

  3419.                 Log("扫码", $"品名({barCodeName})，条码({sn})，加载产品信息({model.Code})完成，加载配方(光源={model.LightValue},曝光={model.ExposureTime},增益={model.Gain})...");

  3420.                 errStep = 10;

  3421. #if Online

  3422.                 if (model.LightValue > 0)//光源 - 通道0

  3423.                     lightDev.SetLightDigitalValue(1, model.LightValue);

  3424.                 errStep = 11;

  3425.                 if (model.ExposureTime > 0 || model.Gain > 0)//相机曝光 增益

  3426.                 {

  3427.                     LineCamDev1.SetExposure((float)(model.ExposureTime > 0 ? model.ExposureTime : 0));

  3428.                     LineCamDev1.SetGain((float)(model.Gain > 0 ? model.Gain : 0));

  3429. 

  3430.                     LineCamDev2.SetExposure((float)(model.ExposureTime > 0 ? model.ExposureTime : 0));

  3431.                     LineCamDev2.SetGain((float)(model.Gain > 0 ? model.Gain : 0));

  3432.                 }

  3433. #endif

  3434.                 errStep = 15;

  3435.                 Log("扫码", $"品名({barCodeName})，配方设置完成:光源={model.LightValue},曝光={model.ExposureTime}");

  3436. 

  3437.                 //显示二次判定项和打标项

  3438.                 OnAutoRuning(new RunEventArgs(model));

  3439.                 //加载所有二次判断

  3440.                 

  3441.                 //显示光源亮度

  3442.                 OnAutoRuning(new RunEventArgs(model.LightValue));

  3443.                 //计米器清空

  3444. #if Online

  3445.                 ClearLengthCount();

  3446. #endif

  3447.                 JmFtStart = false;

  3448.                 Thread.Sleep(1000);

  3449. 

  3450.                 //启动ai寻边模型

  3451.                 if (confMgr.SysConfigParams.OpenAIEdge)

  3452.                 {

  3453.                     Log("加载", $"加载ai寻边模型");

  3454.                     OpencvUtils.LoadEdgeMode();

  3455.                 }

  3456.                 //清空相机内存

  3457.                 LineCamDev1.ClearImageQueue();

  3458.                 LineCamDev2.ClearImageQueue();

  3459.                 //if(LineCamDev1.ClearImageQueue())

  3460.                 //{

  3461.                 //    Log("内存", $"相机1清空内存失败！", WarningEnum.High);

  3462.                 //    return false;

  3463.                 //}

  3464.                 //if (LineCamDev2.ClearImageQueue())

  3465.                 //{

  3466.                 //    Log("内存", $"相机2清空内存失败！", WarningEnum.High);

  3467.                 //    return false;

  3468.                 //}

  3469.                 //电机启动

  3470.                 StartMotion();

  3471. 

  3472.                 pStopWatch.Restart();

  3473.                 pRunSpeedWatch.Restart();

  3474.                 //清空安全队列

  3475.                 ScanPhotoInfo tryDe;

  3476.                 while (_matList1.TryDequeue(out tryDe))

  3477.                 {

  3478.                     Thread.Sleep(10);

  3479.                 }

  3480.                 while (_matList2.TryDequeue(out tryDe))

  3481.                 {

  3482.                     Thread.Sleep(10);

  3483.                 }

  3484.                 _isHaveImgL = false;

  3485.                 _isHaveImgR = false;

  3486. 

  3487.                 _marginWidth1 = 0;

  3488.                 _marginWidth2 = 0;

  3489. 

  3490.                 Cam1Cnt = 0;

  3491.                 Cam2Cnt = 0;

  3492.  

  3493.                 defectPuaseList.Clear();

  3494.                 defectDBList.Clear();

  3495.                 defectPuaseImgList.Clear();

  3496. 

  3497.                 System.GC.Collect();

  3498.                 errStep = 16;

  3499.                 LedRun();

  3500.                 _isRuning = true;

  3501.                 _isAuto = true;

  3502.                 statusMgr.GotoAuto();

  3503.                 SendStatus();

  3504.                 CurrProductModel = model;

  3505.                 

  3506.                 //获取模型label

  3507.                 GetDefectAllLabel();

  3508.             }

  3509.             catch (Exception ex)

  3510.             {

  3511.                 Log("运行", $"程序错误-{errStep}:" + ex.Message + "\n", WarningEnum.High);

  3512.             }

  3513. 

  3514.             return ret;

  3515.         }

  3516.         /// <summary>

  3517.         /// 暂停重启

  3518.         /// </summary>

  3519.         /// <returns></returns>

  3520.         public bool ReStartRun()

  3521.         {

  3522.             bool ret = false;

  3523. 

  3524.             Log("启动", "下发启动指令...");

  3525.             if (confMgr.SysConfigParams.OpenPLC)

  3526.             {

  3527.                 if (plcDev.IsInit())

  3528.                 {

  3529.                     plcDev.WriteCoil("DB3.DBX0.1", false);

  3530.                     plcDev.WriteCoil("DB3.DBX0.0", true);//启动

  3531.                 }

  3532.                 else

  3533.                 {

  3534.                     Log("运行", "PLC连接异常！", WarningEnum.High);

  3535.                     return false;

  3536.                 }

  3537.             }

  3538.             else if (confMgr.SysConfigParams.OpenIO)

  3539.             {

  3540.                 bool sts;

  3541.                 ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.暂停按钮), GetIOBitIndex((int)DIName.暂停按钮), out sts);

  3542.                 if (!sts)

  3543.                 {

  3544.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动 ), GetIOBitIndex((int)DOName.启动), true);

  3545.                     Task.Run(async () =>

  3546.                     {

  3547.                         await Task.Delay(500);

  3548.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动), GetIOBitIndex((int)DOName.启动), false);

  3549.                     });

  3550.                 }

  3551.             }

  3552. 

  3553.             pStopWatch.Start();

  3554.             pRunSpeedWatch.Start();

  3555.             Log("启动", $"暂停 -> 继续");

  3556.             LedRun();

  3557.             _isRuning = true;

  3558.             statusMgr.GotoAuto();

  3559.             SendStatus();

  3560.             ret = true;

  3561.             

  3562.             return ret;

  3563.         }

  3564. #endregion

  3565. 

  3566.         #region 文件删除

  3567.         public void DelectPictureFile()

  3568.         {

  3569.             //删除文件

  3570.             Task.Factory.StartNew(() =>

  3571.             {

  3572.                 //图片

  3573.                 if (confMgr.SysConfigParams.DefectSrcImag.AutoDelete)

  3574.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSrcImag.SavePath, confMgr.SysConfigParams.DefectSrcImag.AutoDeleteDays, true);

  3575.                 if (confMgr.SysConfigParams.DefectSmallImag.AutoDelete)

  3576.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSmallImag.SavePath, confMgr.SysConfigParams.DefectSmallImag.AutoDeleteDays, true);

  3577.                 if (confMgr.SysConfigParams.DefectSplicImag.AutoDelete)

  3578.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSplicImag.SavePath, confMgr.SysConfigParams.DefectSplicImag.AutoDeleteDays, true);

  3579.                 if (confMgr.SysConfigParams.CamImag.AutoDelete)

  3580.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.CamImag.SavePath, confMgr.SysConfigParams.CamImag.AutoDeleteDays, true);

  3581. 

  3582.                 //日志

  3583.                 if (confMgr.SysConfigParams.AutoDeleteLog)

  3584.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.LogPath, confMgr.SysConfigParams.AutoDeleteLogData, true);

  3585.             });

  3586.         }

  3587. 

  3588.         #region 数据保存

  3589.        

  3590.         private async void saveCurrRecord(int key)

  3591.         {

  3592.             Records model = null;

  3593.             int step = 0;

  3594.             try

  3595.             {

  3596.                 _isDefect = true;

  3597.                 Log( "入库", $"准备入库key={key}");

  3598.                 //foreach (int itemKey in htTask.Keys) 

  3599.                 //    AddTextEvent(DateTime.Now,"入库", $"htTask {itemKey}");

  3600. 

  3601.                 step = 1;

  3602.                 model = Hashtable.Synchronized(htTask)[key] as Records;

  3603.                 //model = htTask[key] as Records;

  3604.                 step = 2;

  3605.                 if (model.Len == 0)

  3606.                 {

  3607.                     Log("入库完成", $"小于1米不记录");

  3608.                     _isDefect = false;

  3609.                     return;

  3610.                 }

  3611. 

  3612.                 //model.BatchId = batchId;

  3613.                 //model.ReelId = reelId;

  3614.                 //model.ErpLen = erpLen;

  3615.                 while (model.ScannerPhotoCount > model.ScannerPhotoFinishCount)

  3616.                     await Task.Delay(100);

  3617.                 step = 3;

  3618.                 //计算等级标准

  3619.                 List<GradeLimit> gradeLimitList = model.ProductInfo.GradeLimitList;

  3620.                 if (gradeLimitList != null && gradeLimitList.Count > 0)

  3621.                 {

  3622.                     step = 4;

  3623.                     int count;

  3624.                     foreach (GradeLimit item in gradeLimitList)

  3625.                     {

  3626.                         if (model.DefectInfoList != null && model.DefectInfoList.Count > 0)

  3627.                         {

  3628.                             count = model.DefectInfoList.Where(m => m.Code == item.Code).Count();

  3629.                             if (count <= item.A && model.Grade <= 1) model.Grade = 1;

  3630.                             else if (count <= item.B && item.B > 0 && model.Grade <= 2) model.Grade = 2;

  3631.                             else if (count <= item.C && item.C > 0 && model.Grade <= 3) model.Grade = 3;

  3632.                             else if (count <= item.D && item.D > 0 && model.Grade <= 4) model.Grade = 4;

  3633.                             else if (count <= item.E && item.E > 0 && model.Grade <= 5) model.Grade = 5;

  3634.                             else if (count > 0) model.Grade = 6;//不合格

  3635.                             Log("标准判断", $"({key}) 条码({model.BarCode})，标准={(char)(model.Grade + 64)} [{item.Code}:{count};A<={item.A};B<={item.B};C<={item.C};D<={item.D};E<={item.E}]");

  3636.                         }

  3637.                         else

  3638.                         {

  3639.                             model.Grade = 1;

  3640.                             Log("标准判断", $"({key}) 条码({model.BarCode})，标准={(char)(model.Grade + 64)} [{item.Code}:{0};A<={item.A};B<={item.B};C<={item.C};D<={item.D};E<={item.E}]");

  3641.                         }

  3642.                     }

  3643.                     step = 5;

  3644.                 }

  3645.                 model.Qualified = (model.Grade < 6);//是否合格

  3646.                 if (!RecordService.InsertNav(model))

  3647.                     throw new Exception("写库失败！");

  3648.                 Log("入库完成", $"({key}) 条码({model.BarCode})已完成检测-{model.ScannerPhotoCount}-{model.ScannerPhotoFinishCount}。");

  3649.                 htTask.Remove(key);

  3650.                 _isDefect = false;

  3651.             }

  3652.             catch (Exception ex)

  3653.             {

  3654.                 _isDefect = false;

  3655.                 if (model == null) 

  3656.                     Log("入库失败", $"记录({key})不存在{step}！" + ex.Message, WarningEnum.High);

  3657.                 else 

  3658.                     Log("入库失败", $"({key}) 条码({model.BarCode})检测完成,但保存检测记录失败{step}:" + ex.Message, WarningEnum.High);

  3659.             }

  3660.         }

  3661.         #endregion

  3662. 

  3663.         #endregion

  3664. 

  3665.         #region 表格事件查询

  3666.         public DefectInfo GetDefectInfo(long uid)

  3667.         {

  3668.             if (currKey == 0)

  3669.                 return null;

  3670.             Records record = Hashtable.Synchronized(htTask)[currKey] as Records;

  3671.             //var defectInfo = record.DefectInfoList[record.DefectInfoList.Count - e.RowIndex-1];//按顺序索引引用

  3672.             var defectInfo = record.DefectInfoList.FirstOrDefault(m => m.uid == uid);

  3673.             return defectInfo;

  3674.         }

  3675.         #endregion

  3676. 

  3677.         #region 拷贝产品

  3678.         /// <summary>

  3679.         /// 拷贝产品

  3680.         /// </summary>

  3681.         /// <param name="list"></param>

  3682.         /// <param name="liIndex"></param>

  3683.         /// <param name="stepID">流程ID</param>

  3684.         /// <param name="stepInfo">流程</param>

  3685.         /// <returns></returns>

  3686.         public bool ProductCopy(List<Product> list, int liIndex)

  3687.         {

  3688.             Product newProduct = new Product()

  3689.             {

  3690.                 Code = list[liIndex].Code + "_clone",

  3691.                 Name = $"{list[liIndex].Name} (克隆)",

  3692.                 Spec = list[liIndex].Spec,

  3693.                 Material = list[liIndex].Material,

  3694.                 Color = list[liIndex].Color,

  3695.                 ColorName = list[liIndex].ColorName,

  3696.                 ColorValue = list[liIndex].ColorValue,

  3697.                 LightValue = list[liIndex].LightValue,

  3698.                 ExposureTime = list[liIndex].ExposureTime,

  3699. 

  3700.                 Gain = list[liIndex].Gain,

  3701.                 TensionValue = list[liIndex].TensionValue,

  3702.                 Note = list[liIndex].Note,      

  3703.                 ModelName = list[liIndex].ModelName,

  3704.                 DefectAreaLimit = list[liIndex].DefectAreaLimit,

  3705.                 DefectCountLimit = list[liIndex].DefectCountLimit,

  3706.                 DefectPauseForUser = list[liIndex].DefectPauseForUser,

  3707.                 DefectCntLength = list[liIndex].DefectCntLength,

  3708.                 WarnDefect = list[liIndex].WarnDefect,

  3709.                 OpenThicknessDetection = list[liIndex].OpenThicknessDetection,

  3710.                 ThicknessDetectionStopDis = list[liIndex].ThicknessDetectionStopDis,

  3711.                 residueWarnningLen = list[liIndex].residueWarnningLen,

  3712. 

  3713.                 QualifiedLimitList = new List<QualifiedLimit>(),

  3714.                 GradeLimitList = new List<GradeLimit>(),

  3715.                 DefectPauseOption = list[liIndex].DefectPauseOption,

  3716.                 //OrderList = new List<Order>(),

  3717. 

  3718.                 ModifyUserCode = userMgr.LoginUser.Code,

  3719.                 CreateUserCode = userMgr.LoginUser.Code

  3720.             };

  3721.             foreach (var item in list[liIndex].QualifiedLimitList)

  3722.             {

  3723.                 newProduct.QualifiedLimitList.Add(new QualifiedLimit()

  3724.                 {

  3725.                     Code = item.Code,

  3726.                     ZXD = item.ZXD,

  3727.                     Pid = item.Pid,

  3728.                     Name = item.Name,

  3729.                     Area = item.Area,

  3730.                     ContrastTop = item.ContrastTop,

  3731.                     ContrastLower = item.ContrastLower,

  3732. 

  3733.                     IsOR = item.IsOR,

  3734.                     NameCode = item.NameCode,

  3735.                     DefectWarnLength = item.DefectWarnLength,

  3736.                     DefectWarnCnt = item.DefectWarnCnt,

  3737. 

  3738.                     ModifyUserCode = userMgr.LoginUser.Code,

  3739.                     CreateUserCode = userMgr.LoginUser.Code

  3740.                 });

  3741.             }

  3742.             foreach (var item in list[liIndex].GradeLimitList)

  3743.             {

  3744.                 newProduct.GradeLimitList.Add(new GradeLimit()

  3745.                 {

  3746.                     Pid = item.Pid,

  3747.                     Code = item.Code,

  3748.                     A = item.A,

  3749.                     B = item.B,

  3750.                     C = item.C,

  3751.                     D = item.D,

  3752.                     E = item.E,

  3753. 

  3754.                     ModifyUserCode = userMgr.LoginUser.Code,

  3755.                     CreateUserCode = userMgr.LoginUser.Code

  3756.                 });

  3757.             }

  3758.             

  3759.             bool result = PdtService.InsertNav(newProduct);

  3760. 

  3761.             return result;

  3762.         }

  3763.         #endregion

  3764. 

  3765.         #region 加载二次判定项

  3766.         /// <summary>

  3767.         /// 二次项判断名称列表

  3768.         /// </summary>

  3769.         private List<string> DefectItemsPuaseNameList = new List<string>();

  3770.         public void LoadDefectItemsPuase(List<string> list)

  3771.         {

  3772.             DefectItemsPuaseNameList.Clear();

  3773.             foreach (var item in list)

  3774.             {

  3775.                 DefectItemsPuaseNameList.Add(item);

  3776.             }

  3777.             

  3778.         }

  3779.         #endregion

  3780. 

  3781.         #region 二次判断完成修改

  3782.         public Product GetProduct(string name)

  3783.         {

  3784.             return PdtService.GetModelNavByName(name);

  3785.         }

  3786.         /// <summary>

  3787.         /// 删除忽略项

  3788.         /// </summary>

  3789.         /// <param name="curRecord"></param>

  3790.         /// <param name="lstDel"></param>

  3791.         public void DelDefectEdit(Records curRecord, List<DefectInfo> lstDel)

  3792.         {

  3793.             foreach (var item in lstDel)

  3794.             {

  3795.                 curRecord.DefectInfoList.Remove(item);

  3796.                 

  3797.             }

  3798.         }

  3799.         #endregion

  3800. 

  3801.         #region 加载打标判定项

  3802.         /// <summary>

  3803.         /// 打标项判断名称列表

  3804.         /// </summary>

  3805.         private List<string> DefectItemsDBNameList = new List<string>();

  3806.         public void LoadDefectItemsDB(List<string> list)

  3807.         {

  3808.             DefectItemsDBNameList.Clear();

  3809.             foreach (var item in list)

  3810.             {

  3811.                 DefectItemsDBNameList.Add(item);

  3812.             }

  3813. 

  3814.         }

  3815.         #endregion

  3816. 

  3817.         #region 启动打标

  3818.         public void StartDB()

  3819.         {

  3820.             if (confMgr.SysConfigParams.OpenIO)

  3821.             {

  3822.                 bool sts;

  3823.                 ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.打标), GetIOBitIndex((int)DOName.打标), true);

  3824.                 Task.Run(async () =>

  3825.                 {

  3826.                     await Task.Delay(200);

  3827.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.打标), GetIOBitIndex((int)DOName.打标), false);

  3828.                 });

  3829. 

  3830.             }

  3831.         }

  3832.         #endregion

  3833.     }

  3834.     #region 系统事件

  3835.     /// <summary>

  3836.     /// 流程事件

  3837.     /// </summary>

  3838.     public class RunEventArgs : EventArgs

  3839.     {

  3840.         private int _cmd;

  3841.         public int Cmd { get { return _cmd; } }

  3842. 

  3843.         private int _picIndex;

  3844.         public int PicIndex { get { return _picIndex; } }

  3845.         private Mat _pic;

  3846.         public Mat Pic { get { return _pic; } }

  3847.         public RunEventArgs(int index, Mat pic)

  3848.         {

  3849.             this._cmd = 6;

  3850.             this._picIndex = index;

  3851.             this._pic = pic.Clone();

  3852.         }

  3853. 

  3854.         private bool _over;

  3855.         public bool Over { get { return _over; } }

  3856.         public RunEventArgs(bool ov)

  3857.         {

  3858.             this._cmd = 10;

  3859.             this._over = ov;

  3860.         }

  3861. 

  3862.         private List<object[]> _dataRowlist = new List<object[]>();

  3863.         public List<object[]> DataRowlist { get { return _dataRowlist; } }

  3864.         public RunEventArgs(List<object[]> dataRowlist)

  3865.         {

  3866.             this._cmd = 11;

  3867.             this._dataRowlist = dataRowlist;

  3868.         }

  3869. 

  3870.         private Image _defectimg;

  3871.         public Image Defectimg { get { return _defectimg; } }

  3872.         public RunEventArgs(Image defectimg)

  3873.         {

  3874.             this._cmd = 12;

  3875.             this._defectimg = defectimg;

  3876.         }

  3877. 

  3878.         private List<float[]> _points;

  3879.         public List<float[]> Points { get { return _points; } }

  3880.         public RunEventArgs(List<float[]> pints)

  3881.         {

  3882.             this._cmd = 13;

  3883.             this._points = pints;

  3884.         }

  3885. 

  3886.         private double _len;

  3887.         public double Len { get { return _len; } }

  3888.         private double _speed;

  3889.         public double Speed { get { return _speed; } }

  3890.         public RunEventArgs(double len, double spd)

  3891.         {

  3892.             this._cmd = 14;

  3893.             this._len = len;

  3894.             this._speed = spd;

  3895.         }

  3896. 

  3897.         private Mat _Matimg;

  3898.         public Mat DefectMat { get { return _Matimg; } }

  3899.         public RunEventArgs(Mat defectimg)

  3900.         {

  3901.             this._cmd = 15;

  3902.             this._Matimg = defectimg.Clone();

  3903.             //this._Matimg = defectimg;

  3904.         }

  3905. 

  3906.         private int _cam1ImgCnt;

  3907.         public int Cam1ImgCnt { get { return _cam1ImgCnt; } }

  3908.         private int _cam2ImgCnt;

  3909.         public int Cam2ImgCnt { get { return _cam2ImgCnt; } }

  3910.         private int _defectImgCnt;

  3911.         public int DeefectImgCnt { get { return _defectImgCnt; } }

  3912.         private int _saveImgCnt;

  3913.         public int SaveImgCnt { get { return _saveImgCnt; } }

  3914. 

  3915.         private string _definfoCnt;

  3916.         public string _DefinfoCnt { get { return _definfoCnt; } }

  3917.         public RunEventArgs(int cnt1, int cnt2, string definfo)

  3918.         {

  3919.             this._cmd = 16;

  3920.             this._cam1ImgCnt = cnt1;

  3921.             this._cam2ImgCnt = cnt2;

  3922.             this._definfoCnt = definfo;

  3923.         }

  3924. 

  3925.         public RunEventArgs(int cnt1, int cnt2, int cnt3)

  3926.         {

  3927.             this._cmd = 20;

  3928.             //this._cam1ImgCnt = cnt1;

  3929.             //this._cam2ImgCnt = cnt2;

  3930.             this._saveImgCnt = cnt3;

  3931.         }

  3932. 

  3933.         private int _lightValue;

  3934.         public int LightValue { get { return _lightValue; } }

  3935.         public RunEventArgs(int val)

  3936.         {

  3937.             this._cmd = 17;

  3938.             this._lightValue = val;

  3939.         }

  3940. 

  3941.         private Product _md;

  3942.         public Product MD { get { return _md; } }

  3943.         public RunEventArgs(Product md)

  3944.         {

  3945.             this._cmd = 18;

  3946.             this._md = md;

  3947.         }

  3948. 

  3949.         private int _imgIndex;

  3950.         public int ImgIndex { get { return _imgIndex; } }

  3951. 

  3952.         private List<DefectInfo> _lstEditDefect;

  3953.         public List<DefectInfo> LstEditDefect { get { return _lstEditDefect; } }

  3954. 

  3955.         private List<DefectInfo> _lstEditInfo;

  3956.         public List<DefectInfo> LstEditInfo { get { return _lstEditInfo; } }

  3957. 

  3958.         private Records _records;

  3959.         public Records Records { get { return _records; } }

  3960. 

  3961.         private Mat _tagImg;

  3962.         public Mat TagImg { get { return _tagImg; } }

  3963.         public RunEventArgs(int index, List<DefectInfo> lstEditDefect, Records currRecord, Mat img, List<DefectInfo> lstEditInfo)

  3964.         {

  3965.             this._cmd = 19;

  3966.             this._imgIndex = index;

  3967.             this._lstEditDefect = lstEditDefect;

  3968.             this._records = currRecord;

  3969.             this._tagImg = img;

  3970.             this._lstEditInfo = lstEditInfo;

  3971.         }

  3972. 

  3973.         public RunEventArgs(int index, List<DefectInfo> lstEditDefect, Records currRecord, Mat img)

  3974.         {

  3975.             this._cmd = 21;

  3976.             this._imgIndex = index;

  3977.             this._lstEditDefect = lstEditDefect;

  3978.             this._records = currRecord;

  3979.             this._tagImg = img;

  3980.         }

  3981.     }

  3982.     /// <summary>

  3983.     /// 主窗体事件

  3984.     /// </summary>

  3985.     public class MainEventArgs : EventArgs

  3986.     {

  3987.         private string _tag;

  3988.         public string Tag { get { return _tag; } }

  3989. 

  3990.         private string _message;

  3991.         public string Message { get { return _message; } }

  3992. 

  3993.         private int _showIndex;

  3994.         public int ShowIndex { get { return _showIndex; } }

  3995. 

  3996.         private WarningEnum _warning;

  3997.         public WarningEnum Warning { get { return _warning; } }

  3998. 

  3999.         private bool _show;

  4000.         public bool show {  get { return _show; } }

  4001.         public MainEventArgs(int index)

  4002.         {

  4003.             this._showIndex = index;

  4004.             this._show = true;

  4005.         }

  4006.         public MainEventArgs(int index, string message)

  4007.         {

  4008.             this._message = message;

  4009.             this._showIndex = index;

  4010.             this._show = true;

  4011.         }

  4012.         public MainEventArgs(string tag, string message, WarningEnum warning = WarningEnum.Normal)

  4013.         {

  4014.             this._tag = tag;

  4015.             this._message = message;

  4016.             this._showIndex = 0;

  4017.             this._warning = warning;

  4018.             this._show = true;

  4019.         }

  4020.         public MainEventArgs(string tag, string message, WarningEnum warning = WarningEnum.Normal, bool Show = true)

  4021.         {

  4022.             this._tag = tag;

  4023.             this._message = message;

  4024.             this._showIndex = 0;

  4025.             this._warning = warning;

  4026.             this._show = Show;

  4027.         }

  4028.     }

  4029.     /// <summary>

  4030.     /// 初始化事件

  4031.     /// </summary>

  4032.     public class InitEventArgs : EventArgs

  4033.     {

  4034.         private string _message;

  4035.         public string Message { get { return _message; } }

  4036. 

  4037.         private bool _isInitialized;

  4038.         public bool IsInitialized { get { return _isInitialized; } }

  4039.         public InitEventArgs()

  4040.         {

  4041. 

  4042.         }

  4043.         public InitEventArgs(string message, bool isInitialized = false)

  4044.         {

  4045.             this._message = message;

  4046.             this._isInitialized = isInitialized;

  4047.         }

  4048.     }

  4049.     #endregion

  4050. }