CPL
/
geboshi_V2
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
革博士V2程序
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
10 Revize
2 Větve
904 MiB
 
Strom: ad607c35e5
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „ad607c35e5“
${ noResults }
geboshi_V2/LeatherProject/GeBoShi/SysCtrl/SysMgr.cs

4334 řádky
210 KiB
Surový Blame Historie 

  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 DocumentFormat.OpenXml.Wordprocessing;

  10. using GeBoShi.ImageDefect;

  11. using GeBoShi.UI.InageShow;

  12. using GeBoShi.UI.Product;

  13. using HalconDotNet;

  14. using HZH_Controls;

  15. using HZH_Controls.Forms;

  16. using K4os.Hash.xxHash;

  17. using MaiMuControl.Device;

  18. using MaiMuControl.Device.CamDev;

  19. using MaiMuControl.Device.IOCardDev;

  20. using MaiMuControl.Device.IOCardDev.Advantech;

  21. using MaiMuControl.Device.LightDev;

  22. using MaiMuControl.Device.LightDev.CST;

  23. using MaiMuControl.Device.LightDev.Rsee;

  24. using MaiMuControl.Device.PlcDev;

  25. using MaiMuControl.SysStatusMgr.CloudMgr;

  26. using MaiMuControl.SysStatusMgr.StatusMgr;

  27. using MaiMuControl.SysStatusMgr.UserMgr;

  28. using MaiMuControl.Utils;

  29. using Models;

  30. using Newtonsoft.Json;

  31. using Newtonsoft.Json.Linq;

  32. using OpenCvSharp;

  33. using OpenCvSharp.Extensions;

  34. using S7.Net;

  35. using SqlSugar;

  36. using System;

  37. using System.Collections;

  38. using System.Collections.Concurrent;

  39. using System.Collections.Generic;

  40. using System.ComponentModel;

  41. using System.Data;

  42. using System.Diagnostics;

  43. using System.Drawing;

  44. using System.Drawing.Imaging;

  45. using System.IO;

  46. using System.IO.Ports;

  47. using System.Linq;

  48. using System.Net.Mail;

  49. using System.Threading;

  50. using System.Threading.Tasks;

  51. using System.Windows.Forms;

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

  53. using System.Windows.Forms.VisualStyles;

  54. using ToolKits.Disk;

  55. using ToolKits.Http;

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

  57. 

  58. namespace GeBoShi.SysCtrl

  59. {

  60.     /// <summary>

  61.     /// 主系统控制

  62.     /// </summary>

  63.     public class SysMgr

  64.     {

  65.         #region singleton实例化

  66.         private static SysMgr _instance;

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

  68.         public static SysMgr Instance

  69.         {

  70.             get

  71.             {

  72.                 if (_instance == null)

  73.                 {

  74.                     lock (_lock)

  75.                     {

  76.                         if (_instance == null)

  77.                         {

  78.                             _instance = new SysMgr();

  79.                         }

  80.                     }

  81.                 }

  82.                 return _instance;

  83.             }

  84.         }

  85.         #endregion

  86. 

  87.         #region 私有

  88.         //系统状态

  89.         private StatusMgr statusMgr;

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

  91.         //用户管理

  92.         private GeBoShi.UI.User.UserMgr userMgr;

  93.         public GeBoShi.UI.User.UserMgr UserMgr { get { return userMgr; } }

  94. 

  95.         //系统配置管理

  96.         private ConfMgr confMgr;

  97. 

  98.         //图像处理

  99.         private DefectLib defectLib;

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

  101. 

  102.         //产品检测列表

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

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

  105. 

  106.         //产品ID列表

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

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

  109. 

  110.         /// <summary>

  111.         /// 当前产品

  112.         /// </summary>

  113.         private Models.Product CurrProductModel = null;

  114. 

  115.         //数据锁

  116.         private object lockCurrKey = new object();

  117.         //当前运行数据key

  118.         private int currKey = 0;

  119.         //线程管控

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

  121. 

  122.         //是否处理完成

  123.         private bool _isDefect = false;

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

  125.         private Stopwatch pStopWatch = new Stopwatch();

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

  127.         private Stopwatch pRunSpeedWatch = new Stopwatch();

  128. 

  129.         private object lock_defectPuase = new object();

  130.         /// <summary>

  131.         /// 二次判定缺陷

  132.         /// </summary>

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

  134.         /// <summary>

  135.         /// 

  136.         /// </summary>

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

  138.         //实时速度

  139.         private double ActiveSpeed = 0;

  140.         //图片队列     

  141.         private int _DefectEnd = 0;

  142.         private double _NarmalWidth = 0; //正常幅宽

  143.         private int listCntMax = 60;

  144.         private int Cam1Cnt = 0;

  145.         private int Cam2Cnt = 0;

  146. 

  147.         int _marginWidth1 = 0;

  148.         int _marginWidth2 = 0;

  149.         /// <summary>

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

  151.         /// </summary>

  152.         private bool DefectPauseForUser = true;

  153.         /// <summary>

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

  155.         /// </summary>

  156.         private bool JmFtStart = false;

  157.         /// <summary>

  158.         /// 界面光源值

  159.         /// </summary>

  160.         private int FrmLightValue = 0;

  161. 

  162.         private string ImgDirSN = "";

  163.         #region 处理类型

  164.         private class ScanPhotoInfo

  165.         {

  166.             /// <summary>

  167.             /// 

  168.             /// </summary>

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

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

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

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

  173.             {

  174.                 devIndex = _devIndex;

  175.                 photoIndex = _photoIndex;

  176.                 path = _path;

  177.             }

  178.             public ScanPhotoInfo(int _devIndex, int _photoIndex, Mat _mat, bool haveEdge = true)

  179.             {

  180.                 devIndex = _devIndex;

  181.                 photoIndex = _photoIndex;

  182.                 mat = _mat;

  183.                 EdgeSts = haveEdge;

  184.             }

  185.             public int devIndex { get; set; }

  186.             /// <summary>

  187.             /// 0-n 

  188.             /// </summary>

  189.             public int photoIndex { get; set; }

  190.             public string path { get; set; }

  191.             public Mat mat { get; set; }

  192. 

  193.             public bool EdgeSts { get; set; }

  194. 

  195.         }

  196.         #endregion

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

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

  199. 

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

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

  202. 

  203.         private bool _isOpenIO;

  204. 

  205.         private bool _isHaveImgL;

  206.         private bool _isHaveImgR;

  207.         #endregion

  208. 

  209.         #region 公开字段

  210.         private bool _isInit;

  211.         /// <summary>

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

  213.         /// </summary>

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

  215.         private bool _isRuning;

  216.         /// <summary>

  217.         /// 设备正在运行

  218.         /// </summary>

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

  220. 

  221.         private bool _isAuto;

  222.         /// <summary>

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

  224.         /// </summary>

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

  226.         #endregion

  227. 

  228.         #region 私有流程

  229.         //主流程

  230.         private Thread _mainThread;

  231.         private Thread _Cam1Thread;

  232.         private Thread _Cam2Thread;

  233.         private Thread _SpeedThread;

  234.         private Thread _SaveImgThread;

  235.         private CancellationTokenSource _cts;

  236. 

  237.         private Form _FatherFrm;

  238.         private object _lockOpenCV = new object();

  239.         #endregion

  240. 

  241.         #region 云端

  242.         //局域网云端

  243.         private bool init_Cloud;

  244.         private CloudMgr cloudMgr;

  245.         private int DailyOutput;

  246.         #endregion

  247.         private SysMgr()

  248.         {

  249.             _isInit = false;

  250.             _isRuning = false;

  251.             _isAuto = false;

  252. 

  253.             statusMgr = StatusMgr.Instance;

  254.             confMgr = ConfMgr.Instance;

  255. 

  256.             userMgr = new GeBoShi.UI.User.UserMgr(statusMgr.MySqlIP);

  257. 

  258.             _cts = new CancellationTokenSource();

  259. 

  260.             init_Cloud = false;

  261.             cloudMgr = new CloudMgr();

  262.             DailyOutput = 0;

  263. 

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

  265.             PdtService = new Service.ProductService();

  266.             RecordService = new Service.RecordsService();

  267.         }

  268. 

  269.         #region 本地云上传

  270.         /// <summary>

  271.         /// 上传当日产量

  272.         /// </summary>

  273.         private void SendDailyOutput()

  274.         {

  275.             //开启云端

  276.             if (init_Cloud)

  277.             {

  278.                 try

  279.                 {

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

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

  282.                 }

  283.                 catch (Exception e)

  284.                 {

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

  286.                 }

  287.             }

  288.         }

  289.         /// <summary>

  290.         /// 上传正常状态

  291.         /// </summary>

  292.         public void SendStatus()

  293.         {

  294.             //开启云端

  295.             if (init_Cloud)

  296.             {

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

  298.                 string statusStr = "正常";

  299.                 switch (StatusMgr.Status)

  300.                 {

  301.                     case SystemStsEnum.Manual:

  302.                         statusStr = "人工操作";

  303.                         break;

  304.                     case SystemStsEnum.Standby:

  305.                         statusStr = "正常待机";

  306.                         break;

  307.                     case SystemStsEnum.Initial:

  308.                         statusStr = "初始化";

  309.                         break;

  310.                     case SystemStsEnum.Auto:

  311.                         statusStr = "自动运行";

  312.                         break;

  313.                     case SystemStsEnum.Pause:

  314.                         statusStr = "自动暂停";

  315.                         break;

  316.                     case SystemStsEnum.SetParams:

  317.                         statusStr = "参数设置";

  318.                         break;

  319.                     case SystemStsEnum.Debug:

  320.                         statusStr = "调试";

  321.                         break;

  322.                     case SystemStsEnum.Warning:

  323.                         statusStr = "系统报警";

  324.                         break;

  325.                     case SystemStsEnum.Bootload:

  326.                         statusStr = "Bootload";

  327.                         break;

  328.                     default:

  329.                         statusStr = "未知";

  330.                         break;

  331.                 }

  332.                 try

  333.                 {

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

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

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

  337.                 }

  338.                 catch (Exception e)

  339.                 {

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

  341.                 }

  342.             }

  343.         }

  344.         #endregion

  345. 

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

  347.         /// <summary>

  348.         /// 登入

  349.         /// </summary>

  350.         /// <returns></returns>

  351.         public bool LoginSystem()

  352.         {

  353.             return userMgr.UserLoginDialog();

  354.         }

  355.         /// <summary>

  356.         /// 用户权限

  357.         /// </summary>

  358.         public void UserPermissiomMgr()

  359.         {

  360.             userMgr.RightManageDialog();

  361.         }

  362.         /// <summary>

  363.         /// 用户管理

  364.         /// </summary>

  365.         public void UserListMgr()

  366.         {

  367.             userMgr.UserManagerDialog();

  368.         }

  369.         #endregion

  370. 

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

  372.         /// <summary>

  373.         /// 系统初始化

  374.         /// </summary>

  375.         /// <returns></returns>

  376.         public bool Initial()

  377.         {

  378.             try

  379.             {

  380.                 bool ret = false;

  381.                 string err = "";

  382.                 ret = confMgr.LoadSystemConfig();

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

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

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

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

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

  388.                 //Thread.Sleep(200);

  389.                 int minWorker, minIOC;

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

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

  392. 

  393.                 // 加载系统配置

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

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

  396. 

  397.                 if (!ret)

  398.                 {

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

  400.                 }

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

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

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

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

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

  406.                 statusMgr.GotoInitial();

  407.                 SendStatus();

  408.                 //Thread.Sleep(200);

  409. 

  410. 

  411.                 // 硬件初始化

  412.                 if (!InitAllDev())

  413.                 {

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

  415.                 }

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

  417. 

  418.                 // 加载硬件配置

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

  420.                 if (!LoadDevConfig())

  421.                 {

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

  423.                 }

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

  425.                 //Thread.Sleep(200);

  426.                 // 处理运行

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

  428.                 defectLib = new DefectLib();

  429.                 if (!defectLib.start())

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

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

  432. 

  433.                 LedReady();

  434. 

  435.                 //初始化成功

  436.                 _isInit = true;

  437.                 statusMgr.GotoNormalStandby();

  438.                 SendStatus();

  439. 

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

  441. 

  442.                 Run();

  443. 

  444.                 return ret;

  445.             }

  446.             catch (Exception ex)

  447.             {

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

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

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

  451.                 return false;

  452.             }

  453.         }

  454. 

  455.         /// <summary>

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

  457.         /// </summary>

  458.         /// <returns></returns>

  459.         public bool InitDefectEvent()

  460.         {

  461.             if (defectLib != null)

  462.             {

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

  464.                 {

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

  466.                 };

  467.                 return true;

  468.             }

  469.             return false;

  470.         }

  471. 

  472.         public bool InitCloudConnect()

  473.         {

  474.             if (confMgr.SysConfigParams.OpenCloud)

  475.             {

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

  477.                     confMgr.SysConfigParams.CloudUser, confMgr.SysConfigParams.CloudPassword))

  478.                 {

  479.                     init_Cloud = true;

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

  481.                     return true;

  482.                 }

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

  484.                 return false;

  485.             }

  486.             return true;

  487.         }

  488.         /// <summary>

  489.         /// 运行主线程

  490.         /// </summary>

  491.         private void Run()

  492.         {

  493.             _mainThread = new Thread(() =>

  494.             {

  495.                 MainThreadFunction();

  496.             });

  497.             _mainThread.IsBackground = true;

  498.             _mainThread.Start();

  499. 

  500. #if Online_One

  501. #else

  502.             _Cam1Thread = new Thread(() =>

  503.             {

  504.                 Cam1ThreadFunction();

  505.             });

  506.             _Cam1Thread.IsBackground = true;

  507.             _Cam1Thread.Start();

  508. 

  509.             _Cam2Thread = new Thread(() =>

  510.             {

  511.                 Cam2ThreadFunction();

  512.             });

  513.             _Cam2Thread.IsBackground = true;

  514.             _Cam2Thread.Start();

  515. #endif

  516.             _SpeedThread = new Thread(() =>

  517.             {

  518.                 GetLenAndSpd();

  519.             });

  520.             _SpeedThread.IsBackground = true;

  521.             _SpeedThread.Start();

  522. 

  523.             _SaveImgThread = new Thread(() =>

  524.             {

  525.                 SaveImgThreadFunction();

  526.             });

  527.             _SaveImgThread.IsBackground = true;

  528.             _SaveImgThread.Start();

  529.         }

  530.         #endregion

  531. 

  532.         #region 二次判断开关

  533.         public void SetDefectPause(bool val)

  534.         {

  535.             DefectPauseForUser = val;

  536.         }

  537. 

  538.         public bool GetDefectPause()

  539.         {

  540.             return DefectPauseForUser;

  541.         }

  542.         #endregion

  543. 

  544.         #region 界面光源设置

  545.         public void SetLightValue(int val)

  546.         {

  547.             FrmLightValue = val;

  548.             if(IsInit)

  549.                 lightDev.SetLightDigitalValue(1, val);

  550.         }

  551.         #endregion

  552. 

  553.         #region 计米器控制

  554.         /// <summary>

  555.         /// 计米器清空

  556.         /// </summary>

  557.         private void ClearLengthCount()

  558.         {

  559.             if (confMgr.SysConfigParams.OpenLengthCount)

  560.             {

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

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

  563.                 //Thread.Sleep(100);

  564.                 Thread.Sleep(10);

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

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

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

  568.                 int readCnt = lengthCounter.BytesToRead;

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

  570.             }

  571.         }

  572. 

  573.         /// <summary>

  574.         /// 获取计米数据

  575.         /// </summary>

  576.         /// <returns></returns>

  577.         private double GetLength()

  578.         {

  579.             //bool isFile = true;

  580.             double length = -1;

  581.             bool GetData = false;

  582.             if (lengthCounter.IsOpen)

  583.             {

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

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

  586.                 Thread.Sleep(10);

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

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

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

  590.                 int readCnt = lengthCounter.BytesToRead;

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

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

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

  594.                 {

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

  596.                     {

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

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

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

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

  601.                         GetData = true;

  602.                     }

  603.                 }

  604.                 if (GetData)

  605.                 {

  606.                     if (BitConverter.IsLittleEndian)

  607.                         Array.Reverse(bytes);

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

  609.                     length = spddata / 100.0;

  610. 

  611.                     //if (isFile)

  612.                     //    length = -length;

  613.                 }

  614.                 if (length > 10000)

  615.                     return -1;

  616.             }

  617.             return length;

  618.         }

  619.         #endregion

  620. 

  621.         #region 后台

  622.         private object LockSpd = new object();

  623.         private void SedSpd(double spd)

  624.         {

  625.             lock (LockSpd)

  626.             {

  627.                 ActiveSpeed = spd;

  628.             }

  629.         }

  630.         private double GetSpd()

  631.         {

  632.             double spd;

  633.             lock (LockSpd)

  634.             {

  635.                 spd = ActiveSpeed;

  636.             }

  637.             return spd;

  638.         }

  639.         /// <summary>

  640.         /// 中断工序运行

  641.         /// </summary>

  642.         /// <returns></returns>

  643.         private bool isBreakProcessRun()

  644.         {

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

  646.         }

  647. 

  648.         /// <summary>

  649.         /// 获取缺陷数据

  650.         /// </summary>

  651.         /// <param name="liPhotoIndex"></param>

  652.         /// <returns></returns>

  653.         private List<DefectInfo>  GetDefectListInfo(int liPhotoIndex)

  654.         {

  655.             List<DefectInfo> ret;

  656.             lock (lock_defectPuase)

  657.             {

  658.                   ret = defectPuaseList.Where(m => m.PhotoIndex == liPhotoIndex).ToList();

  659.             }

  660.             return ret;

  661.         }

  662. 

  663.         /// <summary>

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

  665.         /// </summary>

  666.         private void GetLenAndSpd()

  667.         {

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

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

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

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

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

  673.             double UseTime = 1;

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

  675.             double rioSpd = 0.3;//过冲

  676.             while (true)

  677.             {

  678.                 int spdcnt = 0;

  679.                 try

  680.                 {

  681.                     if (_cts.IsCancellationRequested)

  682.                         break;

  683. 

  684.                     if (IsRuning)

  685.                     {

  686.                         ////暂停开始

  687.                         //stopWatch.Start();

  688.                         do

  689.                         {

  690. #if Online

  691.                             if (currKey > 0)

  692.                             {

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

  694.                                 #region 实时速度

  695. 

  696.                                 if (confMgr.SysConfigParams.OpenLengthCount)

  697.                                 {

  698.                                     double length = GetLength();

  699.                                     if (length >= 0)

  700.                                     {

  701.                                         if (!JmFtStart)

  702.                                         {

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

  704.                                             stl = 0;

  705.                                             spl = 0;

  706.                                             cehouDis = 0;

  707.                                             JmFtStart = true;

  708.                                             pRunSpeedWatch.Restart();

  709.                                         }

  710.                                         else

  711.                                         {

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

  713.                                             double dt = pRunSpeedWatch.ElapsedMilliseconds;

  714.                                             if (dt / 1000.0d > UseTime)

  715.                                             {

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

  717.                                                 spl = length;

  718. 

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

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

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

  722.                                                 //{

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

  724.                                                 //}

  725.                                                 

  726.                                                 preSpd = spd;

  727.                                                 SedSpd(spd);

  728. 

  729.                                                 if (spdcnt > 2)

  730.                                                 {

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

  732.                                                     spdcnt = 0;

  733.                                                 }

  734.                                                 spdcnt++;

  735.                                                 //重新计时

  736.                                                 pRunSpeedWatch.Restart();

  737.                                             }

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

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

  740.                                         }

  741.                                         lock (lockCurrKey)

  742.                                         {

  743.                                             curRecord.Len = yqjimi;

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

  745.                                         }

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

  747.                                                                   //显示平均速度

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

  749. 

  750.                                         #region 处理2次判定

  751. 

  752. 

  753.                                         //处理2次判定

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

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

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

  757. 

  758.                                         //计米器判断暂停:瑕疵二次判断

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

  760.                                         {

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

  762.                                             {

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

  764.                                                 {

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

  766.                                                     List<DefectInfo> lstEditDefect0 = GetDefectListInfo(defectPuaseList[0].PhotoIndex);

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

  768.                                                     //瑕疵选项过滤

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

  770.                                                     {

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

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

  773.                                                         {   

  774.                                                             Stop();

  775.                                                             //获取完整数据

  776.                                                             Thread.Sleep(500);

  777.                                                             var lstEditDefect = GetDefectListInfo(defectPuaseList[0].PhotoIndex);

  778.                                                             #region 二级界面

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

  780.                                                             #region 加载界面

  781.                                                             if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  782.                                                             {

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

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

  785.                                                                 Task.Run(() =>

  786.                                                                 {

  787.                                                                     int liDefectCount = lstEditDefect.Count;

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

  789.                                                                     //frmDefect.Show();

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

  791.                                                                     {

  792. 

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

  794. 

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

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

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

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

  799.                                                                     }

  800.                                                                     else

  801.                                                                     {

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

  803.                                                                     }

  804.                                                                 });

  805.                                                             }

  806.                                                             else

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

  808.                                                             #endregion

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

  810.                                                             #endregion

  811.                                                         }

  812.                                                     }

  813. 

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

  815.                                                     

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

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

  818.                                                     {

  819.                                                         Mat mt;

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

  821.                                                     }

  822.                                                     //foreach (var item in lstEditDefect0)

  823.                                                     {

  824.                                                         lock (lock_defectPuase)

  825.                                                         {

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

  827.                                                             //defectPuaseList.Remove(item);

  828.                                                         }

  829.                                                     }

  830.                                                     

  831.                                                 }

  832.                                                 //else

  833.                                                 //{

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

  835.                                                 //}

  836.                                             }

  837.                          

  838.                                         }

  839.                                         #endregion

  840.                                     }

  841.                                 }

  842. 

  843.                                 #endregion

  844. #endif

  845.                             #region 堆积显示

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

  847. 

  848. 

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

  850.                                 #endregion

  851. 

  852. #if Online

  853.                             lock (lockCurrKey)

  854.                                 {

  855.                                     #region 换卷长度提示

  856.                                     if (confMgr.SysConfigParams.OpenLengthCount)

  857.                                     {

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

  859.                                         {

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

  861.                                         }

  862.                                     }

  863.                                     #endregion

  864. 

  865.                                     #region 测厚停止

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

  867.                                     {

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

  869.                                         {

  870.                                             Stop();

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

  872.                                         }

  873.                                     }

  874.                                     #endregion

  875.                                 }

  876.                             }

  877. #endif

  878.                             Thread.Sleep(200);

  879.                         } while (!isBreakProcessRun());

  880.                         //暂停中断

  881.                         //stopWatch.Stop();

  882.                         //pStopWatch.Stop();

  883.                         //_isRuning = false;

  884.                     }

  885.                     Thread.Sleep(10);

  886.                 }

  887.                 catch (Exception e)

  888.                 {

  889.                     _isRuning = false;

  890. 

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

  892.                 }

  893.             }

  894.         }

  895.         /// <summary>

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

  897.         /// </summary>

  898.         private void Cam1ThreadFunction()

  899.         {

  900.             int errStep = 0;

  901.             int marginWidth0 = 0;

  902.             int marginException = 0;

  903. #if Online

  904. #else

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

  906.             Mat timg = new Mat(imgfilePath);

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

  908. #endif

  909.             while (true)

  910.             {

  911.                 try

  912.                 {

  913.                     if (_cts.IsCancellationRequested)

  914.                         break;

  915. 

  916.                     if (IsRuning)

  917.                     {

  918.                         ////暂停开始

  919.                         //stopWatch.Start();

  920.                         do

  921.                         {

  922.                             #region 实时采图

  923. #if Online

  924.                             //采集图片

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

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

  927.                             {

  928. #else

  929.                             Thread.Sleep(2500);

  930.                             AcquisitionMat acq = new AcquisitionMat();

  931.                             {

  932.                                 acq.GrabStatus = "GrabPass";

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

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

  935.                             }

  936.                             

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

  938.                             { 

  939. #endif

  940. 

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

  942. #if true

  943.                                 #region 处理2次判定

  944.                                 if (!confMgr.SysConfigParams.OpenLengthCountStop)

  945.                                 {

  946.                                     //处理2次判定

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

  948.                                     if (DefectPauseForUser )

  949.                                     {

  950.                                         errStep = 11;

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

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

  953. #if false

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

  955.                                         if(havePause != null)

  956.                                         {

  957.                                             foreach (var item in havePause)

  958.                                             {

  959.                                                 liPhotoIndex = item.Key;

  960.                                                 break;

  961.                                             }

  962.                                             

  963.                                         }

  964. #endif

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

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

  967.                                         {

  968.                                             if (defectPuaseList.Count > 0)

  969.                                             { 

  970.                                                 errStep = 12;

  971.                                                 List<DefectInfo> lstEditDefect = GetDefectListInfo(liPhotoIndex);

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

  973.                                                 //瑕疵选项过滤

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

  975.                                                 {

  976.                                                     Log($"二次判断2", $"(图像{liPhotoIndex})需瑕疵二次判断，已达观察台，进入暂停。速度:{GetSpd()},停车缺陷数:{lstEditDefect.Where(x => DefectItemsPuaseNameList.Contains(x.Name)).Count()}");

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

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

  979.                                                     {

  980.                                                         Stop();

  981.                                                         //获取完整数据

  982.                                                         Thread.Sleep(500);

  983. 

  984.                                                         lstEditDefect = GetDefectListInfo(liPhotoIndex);

  985.                                                         //获取完整数据

  986.                                                         #region 二级界面

  987.                                                         #region 加载界面

  988.                                                         if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  989.                                                         {

  990.                                                             Log($"二次判断2", $"(图像{liPhotoIndex})需瑕疵二次判断，缺陷数:{lstEditDefect.Count}");

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

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

  993. #if false

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

  995.                                                             Task.Run(() =>

  996.                                                             {

  997.                                                                 int liDefectCount = lstEditDefect.Count;

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

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

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

  1001.                                                                 {

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

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

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

  1005.                                                                 }

  1006.                                                                 else

  1007.                                                                 {

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

  1009.                                                                 }

  1010.                                                             });

  1011. #endif

  1012.                                                         }

  1013.                                                         else

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

  1015. #endregion

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

  1017. #endregion

  1018.                                                         

  1019.                                                     }

  1020.                                                     errStep = 18;

  1021. 

  1022.                                                 }

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

  1024.                                                 

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

  1026.                                                 

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

  1028.                                                 {

  1029.                                                     Mat mt;

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

  1031.                                                 }

  1032.                                                 //foreach (var item in lstEditDefect)

  1033.                                                 {

  1034.                                                     lock (lock_defectPuase)

  1035.                                                     {

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

  1037.                                                         //defectPuaseList.Remove(item);

  1038.                                                     }

  1039.                                                 }

  1040.                                                 

  1041.                                             }

  1042.                                             else

  1043.                                                 Log($"二次判断2", $"(图像{liPhotoIndex})-缺陷未获得,是否包含在({string.Join(",", DefectItemsPuaseNameList.ToArray())})或({string.Join(",", curRecord.ProductInfo.DefectPauseOption.ToArray())})中。", WarningEnum.Low, false);

  1044. #if false

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

  1046. #endif

  1047.                                         }

  1048.                                         //else

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

  1050.                                     }

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

  1052.                                 }

  1053. #endregion

  1054. #endif

  1055. 

  1056.                                 //预处理

  1057.                                 Stopwatch stopWatch = new Stopwatch();

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

  1059.                                 string time = "";

  1060.                                 stopWatch.Start();

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

  1062.                                 //图像镜像

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

  1064.                                 {

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

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

  1067.                                 }

  1068.                                 else if (confMgr.SysConfigParams.Cam1_flipX)

  1069.                                 {

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

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

  1072.                                 }

  1073.                                 else if (confMgr.SysConfigParams.Cam1_flipY)

  1074.                                 {

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

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

  1077.                                 }

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

  1079.                                 //显示

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

  1081. 

  1082.                                 //lock (_lockOpenCV)

  1083.                                 {

  1084.                                     //存在数据队列

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

  1086.                                     {

  1087.                                         //保存图片

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

  1089.                                         {

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

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

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

  1093. 

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

  1095.                                         }

  1096.                                         if (_matList1.Count > listCntMax)

  1097.                                         {

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

  1099.                                             //_matList1.Dequeue();

  1100.                                             System.GC.Collect();

  1101.                                         }

  1102.                                         

  1103.                                         

  1104.                                         Mat mat = img;

  1105.                                         try

  1106.                                         {

  1107.                                             errStep = 1;

  1108. 

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

  1110.                                             //lock (_lockOpenCV)

  1111.                                             {

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

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

  1114.                                                 {

  1115.                                                     errStep = 3;

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

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

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

  1119.                                                 }

  1120.                                             }

  1121.                                             errStep = 4;

  1122.                                             //左裁边                                           

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

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

  1125.                                             if (_marginWidth1 == 0)

  1126.                                             {

  1127.                                                 _marginWidth1 = marginWidth0;

  1128.                                                 marginException = 0;

  1129.                                             }

  1130. 

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

  1132.                                             {

  1133.                                                 //边缘异常计数

  1134.                                                 marginException++;

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

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

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

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

  1139.                                             }

  1140.                                             else

  1141.                                             {

  1142.                                                 marginException = 0;

  1143.                                                 _marginWidth1 = marginWidth0;

  1144.                                             }

  1145.                                             errStep = 5;

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

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

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

  1149.                                         }

  1150.                                         catch (Exception e)

  1151.                                         {

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

  1153.                                         }

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

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

  1156.                                         _matList1.Enqueue(new ScanPhotoInfo(0, Cam1Cnt++, mat.Clone(), marginException < 1));

  1157.                                     }

  1158.                                     else

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

  1160.                                 }                             

  1161.                             }

  1162.                       

  1163.                             #endregion

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

  1165.                             Thread.Sleep(50);

  1166.                         } while (!isBreakProcessRun());

  1167.                         //暂停中断

  1168.                         //stopWatch.Stop();

  1169.                         pStopWatch.Stop();

  1170.                         //_isRuning = false;

  1171.                     }

  1172.                     else

  1173.                     {

  1174.                         //防止内存爆满

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

  1176.                     }

  1177.                     Thread.Sleep(50);

  1178.                 }

  1179.                 catch (Exception e)

  1180.                 {

  1181.                     _isRuning = false;

  1182. 

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

  1184.                 }

  1185.             }

  1186.         }

  1187.         /// <summary>

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

  1189.         /// </summary>

  1190.         private void Cam2ThreadFunction()

  1191.         {

  1192.             int errStep = 0;

  1193.             int marginWidth0 = 0;

  1194.             int marginException = 0;

  1195. #if Online

  1196. #else

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

  1198.             Mat timg = new Mat(imgfilePath);

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

  1200. #endif

  1201.             while (true)

  1202.             {

  1203.                 try

  1204.                 {

  1205.                     if (_cts.IsCancellationRequested)

  1206.                         break;

  1207. 

  1208.                     if (IsRuning)

  1209.                     {

  1210.                         ////暂停开始

  1211.                         //stopWatch.Start();

  1212.                         do

  1213.                         {

  1214.                             #region 实时采图

  1215. #if Online

  1216.                             //采集图片

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

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

  1219.                             {

  1220. #else

  1221.                             Thread.Sleep(2500);

  1222.                             AcquisitionMat acq = new AcquisitionMat();

  1223.                             {

  1224.                                 acq.GrabStatus = "GrabPass";

  1225.                                 acq.Image = timg;

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

  1227.                             }

  1228. 

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

  1230.                             {

  1231. #endif

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

  1233.                                 //预处理

  1234.                                 Stopwatch stopWatch = new Stopwatch();

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

  1236.                                 string time = "";

  1237.                                 stopWatch.Start(); 

  1238.                                 //图像镜像

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

  1240.                                 {

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

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

  1243.                                 }

  1244.                                 else if (confMgr.SysConfigParams.Cam2_flipX)

  1245.                                 {

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

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

  1248.                                 }

  1249.                                 else if (confMgr.SysConfigParams.Cam2_flipY)

  1250.                                 {

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

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

  1253.                                 }

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

  1255.                                 //显示

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

  1257.                                 //lock (_lockOpenCV)

  1258.                                 {

  1259.                                     //存在数据队列

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

  1261.                                     {

  1262.                                         //保存图片

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

  1264.                                         {

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

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

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

  1268. 

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

  1270.                                         }

  1271.                                         if (_matList2.Count > listCntMax)

  1272.                                         {

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

  1274.                                             //_matList2.Dequeue();

  1275.                                             System.GC.Collect();

  1276.                                         }

  1277.                                         

  1278.                                         

  1279.                                         Mat mat = img;

  1280.                                         try

  1281.                                         {

  1282.                                             errStep = 1;

  1283. 

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

  1285.                                             //lock (_lockOpenCV)

  1286.                                             {

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

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

  1289.                                                 {

  1290.                                                     errStep = 3;

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

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

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

  1294.                                                 }

  1295.                                             }

  1296.                                             errStep = 4;

  1297.                                             //右裁边

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

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

  1300.                                             if (_marginWidth2 == 0)

  1301.                                             {

  1302.                                                 marginException = 0;

  1303.                                                 _marginWidth2 = marginWidth0;

  1304.                                             }

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

  1306.                                             {

  1307.                                                 //边缘异常计数

  1308.                                                 marginException++;

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

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

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

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

  1313.                                             }

  1314.                                             else

  1315.                                             {

  1316.                                                 _marginWidth2 = marginWidth0;

  1317.                                             }

  1318.                                             errStep = 5;

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

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

  1321.                                         }

  1322.                                         catch (Exception e)

  1323.                                         {

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

  1325.                                         }

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

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

  1328.                                         _matList2.Enqueue(new ScanPhotoInfo(1, Cam2Cnt++, mat.Clone(), marginException < 1));

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

  1330.                                     }

  1331.                                     else

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

  1333.                                 }

  1334. 

  1335.                             }

  1336. 

  1337. #endregion

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

  1339.                             Thread.Sleep(50);

  1340.                         } while (!isBreakProcessRun());

  1341.                         //暂停中断

  1342.                         //stopWatch.Stop();

  1343.                         pStopWatch.Stop();

  1344.                         //_isRuning = false;

  1345.                     }

  1346.                     else

  1347.                     {

  1348.                         //防止内存爆满

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

  1350.                     }

  1351.                     Thread.Sleep(50);

  1352.                 }

  1353.                 catch (Exception e)

  1354.                 {

  1355.                     _isRuning = false;

  1356. 

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

  1358.                 }

  1359.             }

  1360.         }

  1361.         int testCnt = 0;

  1362.         /// <summary>

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

  1364.         /// </summary>

  1365.         private void MainThreadFunction()

  1366.         {

  1367.             Mat acq1 = new Mat();

  1368.             Mat acq2 = new Mat();

  1369. #if Online

  1370. #else

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

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

  1373.             Mat timg1 = new Mat(imgfilePath1);

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

  1375.             Mat timg2 = new Mat(imgfilePath2);

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

  1377. #endif

  1378.             while (true)

  1379.             {

  1380.                 int errStep = 0;

  1381.                 try

  1382.                 {

  1383.                     if (_cts.IsCancellationRequested)

  1384.                         break;

  1385. 

  1386.                     if (IsRuning)

  1387.                     {

  1388.                         ////暂停开始

  1389.                         //stopWatch.Start();

  1390.                         do

  1391.                         {

  1392.                             

  1393. #if Online_One

  1394.                             #region 等待图片

  1395. #if Online

  1396.                             //采集图片

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

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

  1399. #else

  1400.                             AcquisitionMat varacq1 = new AcquisitionMat();

  1401.                             {

  1402.                                 varacq1.GrabStatus = "GrabPass";

  1403.                                 varacq1.Image = timg1;

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

  1405.                             }

  1406.                             AcquisitionMat varacq2 = new AcquisitionMat();

  1407.                             {

  1408.                                 varacq2.GrabStatus = "GrabPass";

  1409.                                 varacq2.Image = timg2;

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

  1411.                             }

  1412. 

  1413. 

  1414. #endif

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

  1416.                             {

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

  1418.                                 _isHaveImgL = true;

  1419.                                 Cam1Cnt++;

  1420.                             }

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

  1422.                             {

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

  1424.                                 _isHaveImgR = true;

  1425.                                 Cam2Cnt++;

  1426.                             }

  1427.                             

  1428.                             if (_isHaveImgL && _isHaveImgR)

  1429.                             {

  1430.                                 errStep = 1;

  1431.                                 Stopwatch stopWatch = new Stopwatch();

  1432.                                 string time = "";

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

  1434.                                 try

  1435.                                 {

  1436.                                     if (Cam1Cnt != Cam2Cnt)

  1437.                                     {

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

  1439.                                         continue;

  1440.                                     }

  1441.                                     

  1442.                                     #region 处理2次判定

  1443. 

  1444.                                     if (!confMgr.SysConfigParams.OpenLengthCountStop)

  1445.                                     {

  1446.                                         //处理2次判定

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

  1448.                                         if (DefectPauseForUser)

  1449.                                         {

  1450.                                             stopWatch.Restart();

  1451.                                             errStep = 2;

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

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

  1454.                                             {

  1455.                                                 if (defectPuaseList.Count > 0)

  1456.                                                 {

  1457.                                                     errStep = 3;

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

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

  1460.                                                     //瑕疵选项过滤

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

  1462.                                                     {

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

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

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

  1466.                                                         {

  1467.                                                             Stop();

  1468.                                                             //获取完整数据

  1469.                                                             Thread.Sleep(500);

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

  1471.                                                             //获取完整数据

  1472.                                                             #region 二级界面

  1473.                                                             #region 加载界面

  1474.                                                             if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  1475.                                                             {

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

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

  1478.                                                                 Task.Run(() =>

  1479.                                                                 {

  1480.                                                                     int liDefectCount = lstEditDefect.Count;

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

  1482.                                                                     //frmDefect.Show();

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

  1484.                                                                     {

  1485. 

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

  1487. 

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

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

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

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

  1492.                                                                     }

  1493.                                                                     else

  1494.                                                                     {

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

  1496.                                                                     }

  1497.                                                                 });

  1498.                                                             }

  1499.                                                             else

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

  1501.                                                             #endregion

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

  1503.                                                             #endregion

  1504.                                                         }

  1505.                                                         errStep = 3;

  1506. 

  1507.                                                     }

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

  1509. 

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

  1511. 

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

  1513.                                                     {

  1514.                                                         Mat mt;

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

  1516.                                                     }

  1517.                                                     //foreach (var item in lstEditDefect)

  1518.                                                     {

  1519.                                                         lock (lock_defectPuase)

  1520.                                                         {

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

  1522.                                                             //defectPuaseList.Remove(item);

  1523.                                                         }

  1524.                                                     }

  1525. 

  1526.                                                 }

  1527.                                                 else

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

  1529.                                             }

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

  1531.                                             //else

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

  1533.                                         }

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

  1535.                                     }

  1536. 

  1537.                                     #endregion

  1538. 

  1539.                                     #region 相机图片保存

  1540.                                     errStep = 4;

  1541.                                     //保存图片

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

  1543.                                     {

  1544.                                         stopWatch.Restart();

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

  1546. 

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

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

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

  1550.                                     }

  1551.                                     if (_matList2.Count > listCntMax)

  1552.                                     {

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

  1554.                                         //_matList2.Dequeue();

  1555.                                         System.GC.Collect();

  1556.                                     }

  1557.                                     #endregion

  1558.                                     //预处理

  1559.                                     stopWatch.Restart();

  1560.                                     

  1561.                                     #region 去重

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

  1563.                                     {

  1564.                                         errStep = 6;

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

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

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

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

  1569.                                     }

  1570.                                     #endregion

  1571.                                     #region 裁边

  1572.                                     errStep = 7;

  1573.                                     //左裁边

  1574.                                     int marginWidth0;

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

  1576.                                     //右裁边

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

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

  1579.                                     #endregion

  1580.                                     #region 拼接

  1581.                                     errStep = 8;

  1582.                                     //水平合并l

  1583.                                     Mat mat;

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

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

  1586.                                     #endregion

  1587.                                     #region 镜像

  1588.                                     errStep = 5;

  1589.                                     //图像镜像

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

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

  1592.                                     #endregion

  1593.                                     #region 填充

  1594.                                     errStep = 9;

  1595.                                     //比例缩放图片

  1596.                                     int xw;

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

  1598.                                     if (resizeWidth == 0)

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

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

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

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

  1603.                                     #endregion

  1604.                                     #region 处理

  1605.                                     errStep = 10;

  1606.                                     defectLib.add(new DefectTask()

  1607.                                     {

  1608.                                         modelName = curRecord.ProductInfo.ModelName,

  1609.                                         record = curRecord,

  1610.                                         bmp = mat,

  1611.                                         bmpTag = mat.Clone(),

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

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

  1614.                                         qualifiedLimitList = curRecord.ProductInfo.QualifiedLimitList,

  1615.                                         labelDic = GetDefectCode(),

  1616.                                         finishEvent = callBackDefectEvent,

  1617.                                         xw = xw,

  1618.                                         cm2px_x = confMgr.SysConfigParams.Cm2px_x,

  1619.                                         cm2px_y = confMgr.SysConfigParams.Cm2px_y,

  1620.                                         expand_pixel = confMgr.SysConfigParams.Expand_pixel,

  1621.                                     });

  1622.                                     curRecord.ScannerPhotoCount++;

  1623.                                     errStep = 11;

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

  1625.                                     #endregion

  1626.                                     #region 门幅

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

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

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

  1630.                                         curRecord.FaceWidthMin = faceWidthY_cm;

  1631.                                     if (curRecord.FaceWidthMax < faceWidthY_cm)

  1632.                                         curRecord.FaceWidthMax = faceWidthY_cm;

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

  1634.                                     curRecord.FacePointList.Add(point);

  1635.                                     errStep = 12;

  1636.                                     //判定门幅

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

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

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

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

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

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

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

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

  1645. 

  1646.                                     //显示门幅绘图

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

  1648.                                     errStep = 13;

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

  1650.                                     #endregion

  1651.                                     #region 长度剩余提醒

  1652.                                     errStep = 14;

  1653.                                     //长度剩余提醒

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

  1655.                                     {

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

  1657.                                     }

  1658.                                     #endregion

  1659.                                 }

  1660.                                 catch (Exception ex)

  1661.                                 {

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

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

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

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

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

  1667.                                 }

  1668.                                 finally

  1669.                                 {

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

  1671.                                     //task = null;

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

  1673.                                 }

  1674.                             }

  1675.                             else

  1676.                                 continue;

  1677. 

  1678.                             #endregion

  1679. #else

  1680.                             #region 长度剩余提醒

  1681.                             //长度剩余提醒

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

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

  1684.                             {

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

  1686.                             }

  1687.                             #endregion

  1688. 

  1689.                             #region 图像裁边预处理

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

  1691. #if Online_defect

  1692.                             ScanPhotoInfo peek1;

  1693.                             ScanPhotoInfo peek2;

  1694.                             

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

  1696.                             {

  1697.                                 _matList1.TryPeek(out peek1);

  1698.                                 _matList2.TryPeek(out peek2);

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

  1700.                                     continue;

  1701.                                 Stopwatch stopWatch = new Stopwatch();

  1702.                                 ScanPhotoInfo scanPhotos0; 

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

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

  1705.                                 ScanPhotoInfo scanPhotos1;

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

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

  1708. 

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

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

  1711.                                

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

  1713. 

  1714.                                 string time = "";

  1715.                                 stopWatch.Start();

  1716.                                 try

  1717.                                 {

  1718.                                     Mat mat;

  1719.                                     Mat mat0;

  1720.                                     Mat mat1;

  1721.                                     //lock (_lockOpenCV)

  1722.                                     {

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

  1724.                                         {

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

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

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

  1728.                                             else

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

  1730.                                         }

  1731.                                         errStep = 1;

  1732. 

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

  1734.                                         mat1 = scanPhotos1.mat;

  1735.                                         mat0 = scanPhotos0.mat;

  1736. 

  1737.                                         //水平合并l

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

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

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

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

  1742.                                     }

  1743.                                     errStep = 2;

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

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

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

  1747.  

  1748. #else

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

  1750. 

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

  1752.                             {

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

  1754.                                 break;

  1755.                             }

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

  1757. 

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

  1759.                             {

  1760.                                 Stopwatch stopWatch = new Stopwatch();

  1761.                                

  1762.                                 string time = "";

  1763.                                 //stopWatch.Start();

  1764. 

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

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

  1767. 

  1768.                                 stopWatch.Start();

  1769.                                 errStep = 0;

  1770.                                 try

  1771.                                 {

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

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

  1774.                                     Cam1Cnt++;

  1775.                                     Mat mat0 = scanPhotos1.mat;

  1776.                                     Mat mat1 = scanPhotos0.mat;       

  1777. 

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

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

  1780. #endif

  1781.                                     //显示图片

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

  1783. 

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

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

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

  1787.                                         curRecord.FaceWidthMin = faceWidthY_cm;

  1788.                                     if (curRecord.FaceWidthMax < faceWidthY_cm)

  1789.                                         curRecord.FaceWidthMax = faceWidthY_cm;

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

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

  1792.                                     curRecord.FacePointList.Add(point);

  1793.                                     errStep = 3;

  1794.                                     //判定门幅

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

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

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

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

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

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

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

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

  1803. 

  1804.                                     //显示门幅绘图

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

  1806.                                     errStep = 7;

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

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

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

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

  1811. 

  1812.                                     #region 速度

  1813.                                     //计算速度 

  1814.                                     if (!confMgr.SysConfigParams.OpenLengthCount)

  1815.                                     {

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

  1817.                                         curRecord.Len = lenMi;

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

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

  1820.                                         //显示平均速度

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

  1822.                                         errStep = 9;

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

  1824.                                     }

  1825. 

  1826.                                     #endregion

  1827. #if false

  1828.                                     #region 处理2次判定

  1829.                                     if (!confMgr.SysConfigParams.OpenLengthCountStop)

  1830.                                     {

  1831.                                         //处理2次判定

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

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

  1834.                                         {

  1835.                                             errStep = 11;

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

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

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

  1839.                                             {

  1840.                                                 errStep = 12;

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

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

  1843.                                                 //瑕疵选项过滤

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

  1845.                                                 {

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

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

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

  1849.                                                     {

  1850.                                                         Stop();

  1851.                                                         //获取完整数据

  1852.                                                         Thread.Sleep(500);

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

  1854.                                                         //获取完整数据

  1855.                                                         #region 二级界面

  1856.                                                         #region 加载界面

  1857.                                                         if (defectPuaseImgList.ContainsKey(liPhotoIndex))

  1858.                                                         {

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

  1860.                                                             Task.Run(() =>

  1861.                                                             {

  1862.                                                                 int liDefectCount = lstEditDefect.Count;

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

  1864.                                                                 //frmDefect.Show();

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

  1866.                                                                 {

  1867. 

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

  1869. 

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

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

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

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

  1874.                                                                 }

  1875.                                                                 else

  1876.                                                                 {

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

  1878.                                                                 }

  1879.                                                             });

  1880.                                                         }

  1881.                                                         else

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

  1883.                                                         #endregion

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

  1885.                                                         #endregion

  1886.                                                     }

  1887.                                                     errStep = 18;

  1888. 

  1889.                                                 }

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

  1891.                                                 lock (lock_defectPuase)

  1892.                                                 {

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

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

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

  1896.                                                     foreach (var item in lstEditDefect)

  1897.                                                     {

  1898.                                                         defectPuaseList.Remove(item);

  1899.                                                     }

  1900.                                                 }

  1901.                                             }

  1902.                                         }

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

  1904.                                     }

  1905.                                     #endregion

  1906. #endif

  1907.                              

  1908.                                     //幅宽判断是否为结束

  1909.                                     if (scanPhotos0.photoIndex > 5 && Math.Abs(_NarmalWidth - faceWidthY_cm) > confMgr.SysConfigParams.EndEdgeOffset && _DefectEnd >= 1)

  1910.                                     {

  1911.                                         //出现第二次判断没有边缘

  1912.                                         Log($"图像处理", $"边缘异常或者未找到边缘当作空跑处理：(图像{scanPhotos0.photoIndex})", WarningEnum.Normal, true);

  1913.                                     }

  1914.                                     else if (scanPhotos1.EdgeSts == false && scanPhotos0.EdgeSts == false && _DefectEnd >= 1)

  1915.                                     {

  1916.                                         //出现第二次判断没有边缘

  1917.                                         Log($"图像处理", $"边缘异常或者未找到边缘当作空跑处理：(图像{scanPhotos0.photoIndex})", WarningEnum.Normal, true);

  1918.                                     }

  1919.                                     else

  1920.                                     {

  1921.                                         if (scanPhotos0.photoIndex > 5 && Math.Abs(_NarmalWidth - faceWidthY_cm) > confMgr.SysConfigParams.EndEdgeOffset)

  1922.                                             _DefectEnd++;//没边计数

  1923.                                         else if (scanPhotos1.EdgeSts == false && scanPhotos0.EdgeSts == false)

  1924.                                             _DefectEnd++;//没边计数

  1925.                                         else

  1926.                                         {

  1927.                                             _DefectEnd = 0; //有边的情况重置

  1928.                                             //计算正常幅宽

  1929.                                             _NarmalWidth = faceWidthY_cm;

  1930.                                         }

  1931.                                        

  1932. 

  1933.                                         //----缺陷队列

  1934.                                         //比例缩放图片

  1935.                                         int xw;

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

  1937.                                         if (resizeWidth == 0)

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

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

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

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

  1942.                                         defectLib.add(new DefectTask()

  1943.                                         {

  1944.                                             modelName = curRecord.ProductInfo.ModelName,

  1945.                                             record = curRecord,

  1946.                                             bmp = mat,

  1947.                                             bmpTag = mat.Clone(),

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

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

  1950.                                             qualifiedLimitList = curRecord.ProductInfo.QualifiedLimitList,

  1951.                                             labelDic = GetDefectCode(),

  1952.                                             finishEvent = callBackDefectEvent,

  1953.                                             xw = xw,

  1954.                                             cm2px_x = confMgr.SysConfigParams.Cm2px_x,

  1955.                                             cm2px_y = confMgr.SysConfigParams.Cm2px_y,

  1956.                                             expand_pixel = confMgr.SysConfigParams.Expand_pixel,

  1957.                                         });

  1958.                                         curRecord.ScannerPhotoCount++;

  1959.                                         errStep = 10;

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

  1961.                                     }

  1962.                                 }

  1963.                                 catch (Exception ex)

  1964.                                 {

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

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

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

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

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

  1970.                                 }

  1971.                                 finally

  1972.                                 {

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

  1974.                                     scanPhotos0.mat.Dispose();

  1975.                                     scanPhotos1.mat.Dispose();

  1976.                                     scanPhotos0 = scanPhotos1 = null;

  1977.                                     //task = null;

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

  1979.                                 }

  1980.                             }

  1981.                             #endregion

  1982. #endif

  1983.                             Thread.Sleep(20);

  1984.                         } while (!isBreakProcessRun());

  1985.                         //暂停中断

  1986.                         //stopWatch.Stop();

  1987.                         pStopWatch.Stop();

  1988.                         _isRuning = false;

  1989.                     }

  1990. #if Online_One

  1991.                     else

  1992.                     {

  1993.                         //防止内存爆满

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

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

  1996.                     }

  1997. #endif

  1998.                     Thread.Sleep(20);

  1999.                 }

  2000.                 catch (Exception e)

  2001.                 {

  2002.                     _isRuning = false;

  2003. 

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

  2005.                 }

  2006.             }

  2007.         }

  2008. 

  2009.         

  2010. #endregion

  2011. 

  2012.         #region 模型label

  2013.         private JArray _defectItemList;

  2014.         /// <summary>

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

  2016.         /// </summary>

  2017.         private void GetDefectAllLabel()

  2018.         {

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

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

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

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

  2023.             _defectItemList = defectItemList;

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

  2025.             //if (item == null)

  2026.             //    return null;

  2027.             //return (JObject)item;

  2028.         }

  2029.         

  2030.         public JArray GetDefectItemList()

  2031.         { return _defectItemList; }

  2032.         /// <summary>

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

  2034.         /// </summary>

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

  2036.         /// <returns></returns>

  2037.         public JObject GetDefectLabel(int id)

  2038.         {

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

  2040.             {

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

  2042.                 if (item == null)

  2043.                     return null;

  2044.                 return (JObject)item;

  2045.             }

  2046.             else

  2047.                 return null;

  2048.         }

  2049.         /// <summary>

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

  2051.         /// </summary>

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

  2053.         /// <returns></returns>

  2054.         public JObject GetDefectLabel(string name)

  2055.         {

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

  2057.             {

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

  2059.                 if (item == null)

  2060.                     return null;

  2061.                 return (JObject)item;

  2062.             }

  2063.             else

  2064.                 return null;

  2065.         }

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

  2067.         {

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

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

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

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

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

  2073.             {

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

  2075.                 if (item == null)

  2076.                     return null;

  2077.                 return (JObject)item;

  2078.             }

  2079.             else

  2080.                 return null;

  2081.         }

  2082.         public string GetDefectName(string code)

  2083.         {

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

  2085.             {

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

  2087.                 if (item == null)

  2088.                     return null;

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

  2090.             }

  2091.             else

  2092.                 return null;

  2093.         }

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

  2095.         {

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

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

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

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

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

  2101.             {

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

  2103.                 if (item == null)

  2104.                     return null;

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

  2106.             }

  2107.             else

  2108.                 return null;

  2109.         }

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

  2111.         {

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

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

  2114.             {

  2115.                 var tt = _defectItemList[i];

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

  2117.             }

  2118.             return dic;  

  2119.         }

  2120.         #endregion

  2121. 

  2122.         #region 推理完成处理    

  2123.         private void callBackDefectEvent(DefectTask res)

  2124.         {

  2125.             {

  2126.                 int step = 0;

  2127.                 try

  2128.                 {

  2129.                     Stopwatch stopWatch = new Stopwatch();

  2130.                     stopWatch.Start();

  2131.                     string time = "";

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

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

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

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

  2136. 

  2137.                     //显示打标图片

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

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

  2140.                     else

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

  2142. 

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

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

  2145.                     {

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

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

  2148.                     }

  2149.                     if (res.isSucceed)

  2150.                     {

  2151.                         step = 1;

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

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

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

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

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

  2157.                         step = 2;

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

  2159.                         {

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

  2161.                             

  2162.                             step = 3;

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

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

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

  2166. 

  2167.                             step = 4;

  2168.                             JObject defectNameInfo;

  2169.                             DefectInfo defectInfo = null;

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

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

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

  2173.                             {

  2174.                                 step = 5 + i * 10;

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

  2176.                                 if(defectNameInfo == null)

  2177.                                 {

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

  2179.                                     continue;

  2180.                                 }

  2181.                                 defectInfo = new DefectInfo

  2182.                                 {

  2183.                                     PhotoIndex = res.photoIndex,

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

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

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

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

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

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

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

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

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

  2193.                                     image = DefectPauseForUser? res.lstDefectBmp[i].Clone() : null,

  2194.                                 };

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

  2196.                                 step = 6 + i * 10;

  2197.                                 

  2198.                                 if (DefectPauseForUser && DefectItemsPuaseNameList.Contains(defectInfo.Name))

  2199.                                 {

  2200.                                     lock (lock_defectPuase)

  2201.                                     {

  2202.                                         defectPuaseList.Add(defectInfo);

  2203.                                     }

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

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

  2206.                                 }

  2207.                                 

  2208. 

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

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

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

  2212.                                 step = 7 + i * 10;

  2213.                                 //保存打标小图 

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

  2215.                                 {

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

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

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

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

  2220.                                     defectInfo.TagFilePath = filename;

  2221.                                 }

  2222.                                 step = 8 + i * 10;

  2223. 

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

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

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

  2227. 

  2228.                                 step = 9 + i * 10;

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

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

  2231.                                 {

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

  2233.                                 }

  2234.                                 //必要瑕疵警告

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

  2236.                                 {

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

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

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

  2240.                                     {

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

  2242.                                     }

  2243.                                 }

  2244.                             }

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

  2246. 

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

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

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

  2250.                             {

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

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

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

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

  2255.                             }

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

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

  2258.                             //更新UI

  2259.                             int bmpHeight = res.bmp.Height;

  2260.                             //显示图片

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

  2262.                             //显示瑕疵图

  2263.                             OnAutoRuning(new RunEventArgs(dataRowlist));

  2264. 

  2265.                             step = 9;

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

  2267.                             //保存CSV

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

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

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

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

  2272.                             step = 10;

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

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

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

  2276.                             {

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

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

  2279.                                 {

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

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

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

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

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

  2285.                                     {

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

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

  2288.                                     }

  2289.                                 }

  2290.                                 step = 11;

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

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

  2293.                                 {

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

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

  2296.                                     {

  2297.                                         step = 12;

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

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

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

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

  2302.                                         if (warnDefectCount >= defectWarn.DefectWarnCnt)

  2303.                                         {

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

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

  2306.                                         }

  2307.                                     }

  2308.                                 }

  2309.                             }

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

  2311.                         }

  2312. 

  2313.                     }

  2314.                     else

  2315.                     {

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

  2317.                     }

  2318.                     

  2319. 

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

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

  2322.                     res.bmp.Dispose();

  2323.                     res.bmpTag.Dispose();

  2324.                     res.bmps_cut = null;

  2325.                     res.excelTable.Dispose();

  2326.                 }

  2327.                 catch (Exception ex)

  2328.                 {

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

  2330.                 }

  2331.                 finally

  2332.                 {

  2333.                     res.record.ScannerPhotoFinishCount++;

  2334.                     int liScannerPhotoFinishCount = res.record.ScannerPhotoFinishCount;

  2335.                     int liScannerPhotoCount = res.record.ScannerPhotoCount;

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

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

  2338.                     //{

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

  2340.                     //}));

  2341.                     res = null;

  2342.                     System.GC.Collect();

  2343.                 }

  2344.             }

  2345.         }

  2346.         #endregion

  2347. 

  2348.         #region 图片存储

  2349. 

  2350.         private class SaveImgInfo

  2351.         {

  2352.             public string Path { get; set; }

  2353.             public Mat Img { get; set; }

  2354. 

  2355.             public DataTable DataTable { get; set; }

  2356.         }

  2357. 

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

  2359. 

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

  2361.         {

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

  2363.             //Thread.Sleep(10);

  2364.             if (_SaveImgQueue.Count > 100)

  2365.             {

  2366.                 SaveImgInfo saveImgInfo;

  2367.                 _SaveImgQueue.TryDequeue(out saveImgInfo);

  2368.                 if (saveImgInfo.Img != null)

  2369.                 {

  2370.                     saveImgInfo.Img.Dispose();

  2371.                     saveImgInfo.Img = null;

  2372.                     System.GC.Collect();

  2373.                 }

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

  2375.             }

  2376.         }

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

  2378.         {

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

  2380.         }

  2381.         /// <summary>

  2382.         /// 图片存储

  2383.         /// </summary>

  2384.         private void SaveImgThreadFunction()

  2385.         {

  2386.             while (true)

  2387.             {

  2388.                 try

  2389.                 {

  2390.                     if (_cts.IsCancellationRequested)

  2391.                         break;

  2392.                     SaveImgInfo saveImgInfo;

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

  2394.                     {

  2395.                         if(saveImgInfo.Img != null)

  2396.                         {

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

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

  2399.                             saveImgInfo.Img.Dispose();

  2400.                             saveImgInfo.Img = null; 

  2401.                         }

  2402.                         else

  2403.                         {

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

  2405.                             {

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

  2407.                             }

  2408.                         }

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

  2410.                     }

  2411.                     #region 堆积显示

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

  2413.                     //处理多余

  2414.                     if(_SaveImgQueue.Count > 100)

  2415.                     {

  2416.                         _SaveImgQueue.TryDequeue(out saveImgInfo);

  2417.                         if (saveImgInfo.Img != null)

  2418.                         {

  2419.                             saveImgInfo.Img.Dispose();

  2420.                             saveImgInfo.Img = null;

  2421.                             System.GC.Collect();

  2422.                         }

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

  2424.                     }

  2425.                     #endregion

  2426. 

  2427.                     Thread.Sleep(20);

  2428.                 }

  2429.                 catch (Exception e)

  2430.                 {

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

  2432.                 }

  2433.             }

  2434.         }

  2435.     

  2436.         #endregion

  2437. 

  2438.         #region 结束验布

  2439.         public bool Stop()

  2440.         {

  2441.             Log("暂停", "暂停流程");

  2442.             if (confMgr.SysConfigParams.OpenPLC)

  2443.             {

  2444.                 if (plcDev.IsInit())

  2445.                 {

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

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

  2448.                 }

  2449.                 else

  2450.                 {

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

  2452.                     return false;

  2453.                 }

  2454.             }

  2455.             else if (confMgr.SysConfigParams.OpenIO)

  2456.             {

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

  2458.                 Task.Run(async () =>

  2459.                 {

  2460.                     await Task.Delay(500);

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

  2462.                 });

  2463.             }

  2464.             return true;

  2465.         }

  2466.         public bool DefectEnd(Form fatherFrm)

  2467.         {

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

  2469.             Stop();

  2470.             Thread.Sleep(500);

  2471.             //CurrentState = CurrentStateEnum.初始;

  2472.             _isRuning = false;

  2473.             _isAuto = false;

  2474.             OnAutoRuning(new RunEventArgs(_isAuto));

  2475.             Thread.Sleep(500);

  2476.             pStopWatch.Stop();

  2477.             pRunSpeedWatch.Stop();

  2478.             if (currKey > 0 )

  2479.             {

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

  2481.                 {

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

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

  2484.                     //    Thread.Sleep(200);

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

  2486.                     string szBatchId, szReelId;

  2487.                     double ldErpLen;

  2488.                     //szBatchId = ;

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

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

  2491. 

  2492.                     int myKey = currKey;

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

  2494.                     saveCurrRecord(myKey);

  2495.                     //resetUIValue();

  2496.                     currKey = 0;

  2497. 

  2498. 

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

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

  2501. 

  2502.                 }

  2503.                 else

  2504.                 {

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

  2506.                     return false;

  2507.                 }

  2508.             }

  2509.             else

  2510.             {

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

  2512.                 _isDefect = false;

  2513.                 return false;

  2514.             }

  2515.             return true;

  2516.         }

  2517.         #endregion

  2518. 

  2519.         #region IO解析

  2520.         private int GetIOPortIndex(int DIDOEnum)

  2521.         {

  2522.             return DIDOEnum / 8;

  2523.         }

  2524.         private int GetIOBitIndex(int DIDOEnum)

  2525.         {

  2526.             return DIDOEnum % 8;

  2527.         }

  2528.         #endregion

  2529. 

  2530.         #region 三色灯

  2531.         /// <summary>

  2532.         /// 三色灯初始化

  2533.         /// </summary>

  2534.         public void LedReady()

  2535.         {

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

  2537.             {

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

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

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

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

  2542.             }

  2543.         }

  2544.         /// <summary>

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

  2546.         /// </summary>

  2547.         public void LedRun()

  2548.         {

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

  2550.             { 

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

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

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

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

  2555.             }

  2556.         }

  2557.         /// <summary>

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

  2559.         /// </summary>

  2560.         public void LedPause()

  2561.         {

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

  2563.             {

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

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

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

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

  2568.             }

  2569.         }

  2570.         //控制黄灯闪烁

  2571.         private bool Blink;

  2572.         private int BlinkCnt = 0;

  2573.         //控制蜂鸣间隔

  2574.         private int BuzzCnt = 0;

  2575.         /// <summary>

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

  2577.         /// </summary>

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

  2579.         public void LedRset(bool val)

  2580.         {

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

  2582.             { 

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

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

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

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

  2587. 

  2588.                 Blink = val;

  2589.                 BlinkCnt = 0;

  2590.             }

  2591.         }

  2592.         #endregion

  2593. 

  2594.         #region 报警等、按钮IO

  2595.         /// <summary>

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

  2597.         /// </summary>

  2598.         /// <returns></returns>

  2599.         public bool WarningShowLed(bool DisEnableBuzz)

  2600.         {

  2601.             bool sts = false;

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

  2603.             {

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

  2605.                 {

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

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

  2608.                     else

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

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

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

  2612.                     else

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

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

  2615.                     BuzzCnt = 0;

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

  2617.                     if (Blink)

  2618.                     {

  2619.                         if (BlinkCnt < 3)

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

  2621.                         else if (BlinkCnt < 6)

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

  2623.                         BlinkCnt++;

  2624.                         if (BlinkCnt == 6)

  2625.                             BlinkCnt = 0;

  2626.                     }

  2627.                     else

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

  2629.                 }

  2630.             }

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

  2632.             {

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

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

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

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

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

  2638.                 //sts = true;

  2639.             }

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

  2641.             {

  2642.                 //发送停止信号

  2643.                 Stop();

  2644.                 sts = true;

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

  2646.                 { 

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

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

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

  2650.                     {

  2651.                         if (BuzzCnt < 3)

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

  2653.                         else if (BuzzCnt < 6)

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

  2655.                         BuzzCnt++;

  2656.                         if (BuzzCnt == 6)

  2657.                             BuzzCnt = 0;

  2658.                     }

  2659.                 }

  2660.             }

  2661.             return sts;

  2662.         }

  2663.         /// <summary>

  2664.         /// 按钮IO检测

  2665.         /// </summary>

  2666.         /// <returns></returns>

  2667.         public int ButtonIOTrg(bool DisEnableDoorAlm)

  2668.         {

  2669.             int ret = 0;

  2670.             bool sts;

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

  2672.             {

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

  2674.                 //{

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

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

  2677.                 //    {

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

  2679.                 //        statusMgr.GotoPause();

  2680.                 //        SendStatus();

  2681.                 //        ret = 2;

  2682.                 //    }

  2683.                 //}

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

  2685.                 if (sts)

  2686.                 {

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

  2688.                     statusMgr.GotoPause();

  2689.                     SendStatus();

  2690.                     ret = 2;

  2691.                 }

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

  2693.                 if (sts)

  2694.                 {

  2695.                     ret = 3;

  2696. 

  2697.                 }

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

  2699.                 if (sts)

  2700.                     ret = 1;

  2701.             }

  2702.             return ret;

  2703.         }

  2704.         #endregion

  2705. 

  2706.         #region 系统关闭

  2707.         /// <summary>

  2708.         /// 关闭

  2709.         /// </summary>

  2710.         public void Close()

  2711.         {

  2712.             _isInit = false;

  2713.             _isRuning = false;

  2714.             if (null != _cts)

  2715.             {

  2716.                 _cts.Cancel();

  2717.             }

  2718.             if (null != _mainThread)

  2719.             {

  2720.                 _mainThread.Join(1000);

  2721.             }

  2722.             if (null != _Cam1Thread)

  2723.             {

  2724.                 _Cam1Thread.Join(1000);

  2725.             }

  2726.             if (null != _Cam2Thread)

  2727.             {

  2728.                 _Cam2Thread.Join(1000);

  2729.             }

  2730.             if (null != _SpeedThread)

  2731.             {

  2732.                 _SpeedThread.Join(1000);

  2733.             }

  2734. 

  2735.             if (null != _SaveImgThread)

  2736.             {

  2737.                 _SaveImgThread.Join(1000);

  2738.             }

  2739. 

  2740.             //关闭计米器

  2741.             if (confMgr.SysConfigParams.OpenLengthCount)

  2742.                 lengthCounter.Close();

  2743. 

  2744.             //关闭相机

  2745.             LineCamDev1.CloseCamera();

  2746.             LineCamDev2.CloseCamera();

  2747. 

  2748.             //关闭光源

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

  2750.             {

  2751.                 lightDev.CloseLight(i + 1);

  2752.             }

  2753. 

  2754.             lightDev.CloseDev();

  2755. 

  2756. 

  2757.             //关闭io

  2758.             if (confMgr.SysConfigParams.OpenIO)

  2759.             {

  2760.                 ioCardDev.ResetAllDO();

  2761. 

  2762.                 ioCardDev.CloseBoard();

  2763.             }

  2764. 

  2765.             if (confMgr.SysConfigParams.OpenPLC)

  2766.                 plcDev.CloseDev();

  2767. 

  2768.         }

  2769.         #endregion

  2770. 

  2771.         #region 日志报警

  2772.         /// <summary>

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

  2774.         /// </summary>

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

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

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

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

  2779.         {

  2780.             OnInitRuning(new InitEventArgs(msg));

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

  2782.         }

  2783.         /// <summary>

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

  2785.         /// </summary>

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

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

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

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

  2790.         {

  2791.             if(show)

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

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

  2794.             //开启云端

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

  2796.             {

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

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

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

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

  2801.             }

  2802.         }

  2803.         #endregion

  2804. 

  2805.         #region 硬件 

  2806. 

  2807.         #region 硬件型号配置

  2808.         public LightDevNameEnum SysUseLight = LightDevNameEnum.CST;

  2809.         #endregion

  2810. 

  2811.         #region 硬件字段

  2812.         private CamDev _LinecamDev1;

  2813.         /// <summary>

  2814.         /// io控制卡

  2815.         /// </summary>

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

  2817.         private CamDev _LinecamDev2;

  2818.         /// <summary>

  2819.         /// io控制卡

  2820.         /// </summary>

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

  2822. 

  2823.         private IOCardDev ioCardDev;

  2824.         /// <summary>

  2825.         /// io控制卡

  2826.         /// </summary>

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

  2828. 

  2829.         private LightDev lightDev;

  2830.         /// <summary>

  2831.         /// 光源控制

  2832.         /// </summary>

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

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

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

  2836. 

  2837.         /// <summary>

  2838.         /// 计米器

  2839.         /// </summary>

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

  2841.         private SerialPort lengthCounter;

  2842. 

  2843.         private PlcDev plcDev;

  2844.         /// <summary>

  2845.         /// PLC控制

  2846.         /// </summary>

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

  2848. 

  2849.         private PrintControl printControl;

  2850.         /// <summary>

  2851.         /// 打印机模块

  2852.         /// </summary>

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

  2854.         #endregion

  2855. 

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

  2857.         private void InitDev()

  2858.         { 

  2859.             ioCardDev = new AdvantechIO();

  2860. 

  2861.             //CpuType.S71200 = 30

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

  2863. 

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

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

  2866. 

  2867.             if (SysUseLight == LightDevNameEnum.CST)

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

  2869.             else

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

  2871. 

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

  2873.         }

  2874.         /// <summary>

  2875.         /// 初始化硬件

  2876.         /// </summary>

  2877.         /// <returns></returns>

  2878.         private bool InitAllDev()

  2879.         {

  2880.             bool ret = false;

  2881.             InitDev();

  2882. #if Online

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

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

  2885.             //try

  2886.             //{

  2887.             //    printControl = new PrintControl();

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

  2889.             //}

  2890.             //catch (Exception ex)

  2891.             //{

  2892.             //    printControl = null;

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

  2894.             //}

  2895.             if (confMgr.SysConfigParams.OpenLengthCount)

  2896.             {

  2897.                 lengthCounter.Open();

  2898.                 if (!lengthCounter.IsOpen)

  2899.                 {

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

  2901.                     return ret;

  2902.                 }

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

  2904.             }

  2905.             if (confMgr.SysConfigParams.OpenPLC)

  2906.             {

  2907.                 //PLC初始化

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

  2909.                 if(!plcDev.OpenDev())

  2910.                 {

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

  2912.                     return ret;

  2913.                 }

  2914.                 InitLog("PLC连接成功！");

  2915.             }

  2916.             _isOpenIO = false;

  2917.             if (confMgr.SysConfigParams.OpenIO)

  2918.             {

  2919.                 //IO初始化

  2920.                 InitLog("IO板卡初始化...");

  2921.                 if (ioCardDev.InitBoard(MaiMuControl.Device.IOBordType.Advantech) < 0)

  2922.                 {

  2923.                     InitLog("IO板卡初始化失败！", "初始化", WarningEnum.High);

  2924.                     return ret;

  2925.                 }

  2926.                 if (ioCardDev.OpenBoard(confMgr.SysConfigParams.IODevName, confMgr.SysConfigParams.IOCfgPath) < 0)

  2927.                 {

  2928.                     InitLog("打开IO板卡失败！", "初始化", WarningEnum.High);

  2929.                     return ret;

  2930.                 }

  2931.                 if (ioCardDev.ResetAllDO() < 0)

  2932.                 {

  2933.                     InitLog("IO Reset失败！", "初始化", WarningEnum.High);

  2934.                     return ret;

  2935.                 }

  2936.                 _isOpenIO = true;

  2937.                 InitLog("初始化IO板卡成功！");

  2938.             }

  2939. 

  2940.             //相机初始化

  2941.             if(!_LinecamDev1.InitCamera())

  2942.             {

  2943.                 InitLog("相机1初始化失败！", "初始化", WarningEnum.High);

  2944.                 return ret;

  2945.             }

  2946.             if(!_LinecamDev1.OpenCamera())

  2947.             {

  2948.                 InitLog("相机1打开失败！", "初始化", WarningEnum.High);

  2949.                 return ret;

  2950.             }

  2951.             _LinecamDev1.IsMirrorX = confMgr.SysConfigParams.Cam1_flipX;

  2952.             _LinecamDev1.IsMirrorY = confMgr.SysConfigParams.Cam1_flipY;

  2953.             _LinecamDev1.WarningEvent = (level, msg) =>

  2954.              {

  2955.                  Log($"相机1设备事件", msg, level);

  2956.              };

  2957. 

  2958.             if (!_LinecamDev2.InitCamera())

  2959.             {

  2960.                 InitLog("相机2初始化失败！", "初始化", WarningEnum.High);

  2961.                 return ret;

  2962.             }

  2963.             if (!_LinecamDev2.OpenCamera())

  2964.             {

  2965.                 InitLog("相机2打开失败！", "初始化", WarningEnum.High);

  2966.                 return ret;

  2967.             }

  2968.             _LinecamDev2.IsMirrorX = confMgr.SysConfigParams.Cam2_flipX;

  2969.             _LinecamDev2.IsMirrorY = confMgr.SysConfigParams.Cam2_flipY;

  2970.             _LinecamDev2.WarningEvent = (level, msg) =>

  2971.             {

  2972.                 Log($"相机2设备事件", msg, level);

  2973.             };

  2974.             //光源初始化

  2975.             InitLog("光源控制器初始化...");

  2976.             int com_num = int.Parse(confMgr.SysConfigParams.LightCom.Remove(0, 3));

  2977.             if (lightDev.InitDev(com_num, confMgr.SysConfigParams.LightComBaud) < 0)

  2978.             {

  2979.                 InitLog("光源控制器初始化失败！", "初始化", WarningEnum.High);

  2980.                 return ret;

  2981.             }

  2982.             InitLog("初始化光源控制器成功！");

  2983.             //关闭光源

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

  2985.             {

  2986.                 lightDev.CloseLight(i + 1);

  2987.             }

  2988. #endif

  2989.             ret = true;

  2990.             return ret;

  2991.         }

  2992.         /// <summary>

  2993.         /// 读取硬件配置

  2994.         /// </summary>

  2995.         private bool LoadDevConfig()

  2996.         {

  2997.             LightParams lightParams = new LightParams(LightName, LightChCount);

  2998.             //LightChCount = 6;

  2999.             //lightParams.DevName = LightName;

  3000.             lightParams.ComName = confMgr.SysConfigParams.LightCom;

  3001.             lightParams.Buad = confMgr.SysConfigParams.LightComBaud;

  3002.             //lightParams.ChCount = LightChCount;

  3003.             lightDev.WriteCfgInfo(confMgr.DevConfigPath, lightParams);

  3004.             return true;

  3005.         }

  3006. 

  3007. #endregion

  3008. #endregion

  3009. 

  3010.         #region 硬盘检测

  3011.         public static bool CheckDisk(IWin32Window owner, int max = 10)

  3012.         {

  3013.             if (!string.IsNullOrEmpty(ConfMgr.Instance.SysConfigParams.DefectSrcImag.SavePath))

  3014.             { 

  3015.                 string path = ConfMgr.Instance.SysConfigParams.DefectSrcImag.SavePath;

  3016.                 string volume = path.Substring(0, path.IndexOf(':'));

  3017.                 long freespace = DiskAPI.GetHardDiskSpace(volume);

  3018.                 if (freespace < max)

  3019.                 {

  3020.                     string tip = $"当前{volume}硬盘容量：{freespace}GB，小于{max}GB。注意清理！！";

  3021.                     FrmDialog.ShowDialog(owner, tip, "警告", true);

  3022.                     return false;

  3023.                 }

  3024.             }

  3025.             return true;

  3026.         }

  3027.         #endregion

  3028. 

  3029.         #region 初始化事件

  3030.         /// <summary>

  3031.         /// 初始化回调

  3032.         /// </summary>

  3033.         /// <param name="sender"></param>

  3034.         /// <param name="e"></param>

  3035.         public delegate void InitEventHandler(Object sender, InitEventArgs e);

  3036.         public event InitEventHandler InitRuning;

  3037.         protected virtual void OnInitRuning(InitEventArgs e)

  3038.         {

  3039.             if (null != InitRuning)

  3040.             {

  3041.                 InitRuning(this, e);

  3042.             }

  3043.         }

  3044.         #endregion

  3045. 

  3046.         #region 主窗体显示事件

  3047.         /// <summary>

  3048.         /// 主窗体回调

  3049.         /// </summary>

  3050.         /// <param name="sender"></param>

  3051.         /// <param name="e"></param>

  3052.         public delegate void MainEventHandler(Object sender, MainEventArgs e);

  3053.         public event MainEventHandler MainRuning;

  3054.         protected virtual void OnMainRuning(MainEventArgs e)

  3055.         {

  3056.             if (null != MainRuning)

  3057.             {

  3058.                 MainRuning(this, e);

  3059.             }

  3060.         }

  3061. 

  3062.         /// <summary>

  3063.         /// 流程回调

  3064.         /// </summary>

  3065.         /// <param name="sender"></param>

  3066.         /// <param name="e"></param>

  3067.         public delegate void RunEventHandler(Object sender, RunEventArgs e);

  3068.         public event RunEventHandler AutoRuning;

  3069.         protected virtual void OnAutoRuning(RunEventArgs e)

  3070.         {

  3071.             if (null != AutoRuning)

  3072.             {

  3073.                 AutoRuning(this, e);

  3074.             }

  3075.         }

  3076.         #endregion

  3077. 

  3078.         #region 加载测试列表

  3079.         /// <summary>

  3080.         /// 加载产品列表

  3081.         /// </summary>

  3082.         public void LoadProductCodeList()

  3083.         {

  3084.             try

  3085.             {

  3086.                 productCodeList = PdtService.GetListNav().Select(m => m.Name).ToList();

  3087.                 productIdList = PdtService.GetListNav().Select(m => m.Id).ToList();

  3088.             }

  3089.             catch (Exception ex)

  3090.             {

  3091.                 OnMainRuning(new MainEventArgs("启动", "加载检测标准失败:" + ex.Message, WarningEnum.High));

  3092.                 statusMgr.GotoWarning(WarningEnum.High, "启动", "加载检测标准失败:" + ex.Message);

  3093.                 SendStatus();

  3094.             }

  3095.         }

  3096.         #endregion

  3097. 

  3098.         #region 界面显示

  3099.         public static void showRowNum_onDataGrid_RowPostPaint(DataGridView dgv, object sender, DataGridViewRowPostPaintEventArgs e)

  3100.         {

  3101.             Rectangle rectangle = new Rectangle(e.RowBounds.Location.X, e.RowBounds.Location.Y, dgv.RowHeadersWidth - 4, e.RowBounds.Height);

  3102.             TextRenderer.DrawText(e.Graphics, (e.RowIndex + 1).ToString(), dgv.RowHeadersDefaultCellStyle.Font, rectangle, dgv.RowHeadersDefaultCellStyle.ForeColor, TextFormatFlags.VerticalCenter | TextFormatFlags.Right);

  3103.         }

  3104.         /// <summary>

  3105.         /// IO二进制数据格式化到8位 XXXX10X0

  3106.         /// </summary>

  3107.         /// <param name="datas"></param>

  3108.         /// <returns></returns>

  3109.         public static string[] IODataFormatBinaryStr(string[] datas, bool clone, char defaultPadChar = 'X')

  3110.         {

  3111.             string[] datas2 = new string[datas.Length];

  3112.             for (int i = 0; i < datas.Length; i++)

  3113.             {

  3114.                 if (clone)

  3115.                 {

  3116.                     datas2[i] = datas[i].Replace(" ", "");

  3117.                     if (datas2[i].Length > 8)

  3118.                         datas2[i] = datas2[i].Substring(datas2[i].Length - 8);

  3119.                     else if (datas2[i].Length < 8)

  3120.                         datas2[i] = datas2[i].PadLeft(8, defaultPadChar);

  3121.                 }

  3122.                 else

  3123.                 {

  3124.                     datas[i] = datas[i].Replace(" ", "");

  3125.                     if (datas[i].Length > 8)

  3126.                         datas[i] = datas[i].Substring(datas[i].Length - 8);

  3127.                     else if (datas[i].Length < 8)

  3128.                         datas[i] = datas[i].PadLeft(8, defaultPadChar);

  3129. 

  3130.                     datas2 = datas;

  3131.                 }

  3132.             }

  3133. 

  3134.             return datas2;

  3135.         }

  3136.         /// <summary>

  3137.         /// 

  3138.         /// </summary>

  3139.         /// <param name="op_show_list">[XXHL XXXX,XXXX XXXX,...]</param>

  3140.         /// <param name="currIoDatas">[byte,byte,byte,byte]</param>

  3141.         /// <returns></returns>

  3142.         public static bool compareIOInput(string[] op_show_list, byte[] currIoDatas)

  3143.         {

  3144.             int isok = 0;//1-true 2-false

  3145.             string IN_OP_SHOW;

  3146.             for (int i = 0; i < currIoDatas.Length; i++)

  3147.             {

  3148.                 IN_OP_SHOW = op_show_list[i].Replace(" ", "").PadLeft(8, 'X');

  3149.                 if (IN_OP_SHOW.IndexOf('H') < 0 && IN_OP_SHOW.IndexOf('L') < 0)

  3150.                     continue;

  3151. 

  3152.                 for (int j = 7; j >= 0; j--)

  3153.                 {

  3154.                     byte bit = (byte)(1 << 7 - j);

  3155.                     if (IN_OP_SHOW[j] == 'H')

  3156.                     {

  3157.                         if ((bit & currIoDatas[i]) > 0)

  3158.                             isok = 1;

  3159.                         else

  3160.                         {

  3161.                             isok = 2;

  3162.                             break;

  3163.                         }

  3164.                     }

  3165.                     else if (IN_OP_SHOW[j] == 'L')

  3166.                     {

  3167.                         if ((currIoDatas[i] ^ (currIoDatas[i] | bit)) > 0)

  3168.                             isok = 1;

  3169.                         else

  3170.                         {

  3171.                             isok = 2;

  3172.                             break;

  3173.                         }

  3174.                     }

  3175.                 }

  3176. 

  3177.                 //已经不符

  3178.                 if (isok == 2) break;

  3179.             }

  3180. 

  3181.             //

  3182.             return isok == 1;

  3183.         }

  3184. 

  3185.         #endregion

  3186. 

  3187.         #region 启动

  3188.         public bool StartMotion()

  3189.         {

  3190.             if (confMgr.SysConfigParams.OpenAutoRun)

  3191.             {

  3192.                 Log("启动", "下发启动指令...");

  3193.                 if (confMgr.SysConfigParams.OpenPLC)

  3194.                 {

  3195.                     if (plcDev.IsInit())

  3196.                     {

  3197.                         plcDev.WriteCoil("DB3.DBX0.1", false);

  3198.                         plcDev.WriteCoil("DB3.DBX0.0", true);//启动

  3199.                     }

  3200.                     else

  3201.                     {

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

  3203.                         return false;

  3204.                     }

  3205.                 }

  3206.                 else if (confMgr.SysConfigParams.OpenIO)

  3207.                 {

  3208.                     bool sts;

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

  3210.                     if (!sts)

  3211.                     {

  3212.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动), GetIOBitIndex((int)DOName.启动), true);

  3213.                         Task.Run(async () =>

  3214.                         {

  3215.                             await Task.Delay(500);

  3216.                             ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动), GetIOBitIndex((int)DOName.启动), false);

  3217.                         });

  3218.                     }

  3219.                     else

  3220.                         Log("运行", "存在暂停信号！", WarningEnum.Low);

  3221.                 }

  3222.             }

  3223.             else

  3224.                 Log("启动", "检测流程开启...");

  3225.             return true;

  3226.         }

  3227.         /// <summary>

  3228.         /// 加载ERP数据库数据

  3229.         /// </summary>

  3230.         /// <param name="barCode"></param>

  3231.         /// <returns></returns>

  3232.         private DataRow loadErpData(string barCode)

  3233.         {

  3234.             var paramList = new List<SugarParameter>() {

  3235.                         new SugarParameter("@code", barCode)

  3236.                     };

  3237.             Stopwatch stopwatch = Stopwatch.StartNew();

  3238.             var data = confMgr.execSql(confMgr.SysConfigParams.ErpSql, paramList);

  3239.             if (data != null && data.Rows.Count < 1)

  3240.             {

  3241.                 Log("Erp查询结果", $"{barCode}: 时长={stopwatch.ElapsedMilliseconds}ms, 无数据！", WarningEnum.Normal);

  3242.                 return null;

  3243.             }

  3244. 

  3245.             Log("Erp查询结果", $"{barCode}: 时长={stopwatch.ElapsedMilliseconds}ms, {JsonConvert.SerializeObject(data.Rows[0])}", WarningEnum.Normal);

  3246.             return data.Rows[0];

  3247.         }

  3248.         /// <summary>

  3249.         /// 自动运行

  3250.         /// </summary>

  3251.         /// <returns></returns>

  3252.         public bool StartRun(Form fatherFrm, string sn, ref string DefectName, ref string name, ref string batch, ref string reel, ref string cnt)

  3253.         {

  3254.             bool ret = true;

  3255.             _FatherFrm = fatherFrm;

  3256.             string barCodeName = "", len = "0", batchId = "", reelId = "";

  3257.             if (string.IsNullOrEmpty(name))

  3258.                 name = "未找到";

  3259.             //运行前清除过期图片文件

  3260.             //DateTime st = DateTime.Now;

  3261.             DelectPictureFile();

  3262.             if ((statusMgr.Status != SystemStsEnum.Standby) && (statusMgr.Status != SystemStsEnum.Pause))

  3263.             {

  3264.                 Log("运行", "系统非可运行状态", WarningEnum.Low);

  3265.                 return false;

  3266.             }

  3267. 

  3268.             if (string.IsNullOrEmpty(sn))

  3269.             {

  3270.                 Log("运行", "产品条码为空！", WarningEnum.Low);

  3271.                 return false;

  3272.             }

  3273. 

  3274.             //禾欣数据 sn，长度数量， 批号， 卷号

  3275.             if (!string.IsNullOrWhiteSpace(confMgr.SysConfigParams.ErpDBConStr) && !string.IsNullOrWhiteSpace(confMgr.SysConfigParams.ErpSql) && !string.IsNullOrWhiteSpace(sn))

  3276.             {

  3277.                 Log("扫码", $"产品条码({sn})到ERP查询对应数据...", WarningEnum.Normal);

  3278.                 var rowData = this.loadErpData(sn);

  3279.                 if (rowData == null)

  3280.                 {

  3281.                     Log("扫码", $"产品条码({sn})无对应ERP数据，不做响应！", WarningEnum.High);

  3282.                     return false;

  3283.                 }

  3284. 

  3285.                 barCodeName = rowData[0].ToString();

  3286.                 if (rowData.ItemArray.Length > 1) len = rowData[1].ToString();

  3287.                 if (rowData.ItemArray.Length > 2) batchId = rowData[2].ToString();

  3288.                 if (rowData.ItemArray.Length > 3) reelId = rowData[3].ToString();

  3289.             }

  3290.             else

  3291.                 barCodeName = sn;//没有ERP对应关系时直接使用条码做为品名

  3292. 

  3293.             //Log("调试", $"time1:{(DateTime.Now - st).Milliseconds}");

  3294.             //st = DateTime.Now;

  3295.             int errStep = 0;

  3296.             try

  3297.             {

  3298.                 Product model;

  3299.                 //禾欣客户使用

  3300.                 if (confMgr.SysConfigParams.CustomerName == "hexin")

  3301.                 {

  3302.                     errStep = 1;

  3303.                     //SHNY-PX-6-***

  3304.                     string[] codes = barCodeName.Split(new char[] { '-' });

  3305.                     if (codes.Length < 4)

  3306.                     {

  3307.                         Log("扫码", $"产品品名({barCodeName})格式错误，不做响应！", WarningEnum.Low);

  3308.                         return false;

  3309.                     }

  3310.                     errStep = 2;

  3311.                     //加载新产品  

  3312.                     string pcode = "1-" + codes[2];

  3313.                     if (codes[1] == "0" || confMgr.SysConfigParams.SuedeList.Contains(codes[1]))

  3314.                         pcode = "0-" + codes[2];

  3315.                     model = PdtService.GetModelNav(pcode); //frmProduct.loadProduct(code);

  3316. 

  3317.                     name = barCodeName;

  3318.                     batch = batchId;

  3319.                     reel = reelId;

  3320.                     cnt = len;

  3321.                 }

  3322.                 else if (confMgr.SysConfigParams.CustomerName == "boyi" && confMgr.SysConfigParams.OpenMes)

  3323.                 {

  3324.                     //博艺mes功能

  3325.                     string mjson = GetMesJson(sn);

  3326.                     string mfid = "";

  3327.                     string httprel = "";

  3328.                     if (MesReturn(mjson, out mfid, out httprel))

  3329.                     {

  3330.                         Log("Mes", $"Mes反馈({httprel})", WarningEnum.Normal, false);

  3331.                         JObject Param = JObject.Parse(httprel);

  3332.                         name = Param["List"][0]["Mname"].ToString();

  3333.                         barCodeName = name;

  3334.                         len = Param["List"][0]["PQty"].ToString();

  3335.                         batchId = Param["List"][0]["FID"].ToString();

  3336.                         reelId = Param["List"][0]["RawMFid"].ToString();

  3337.                         //根据mfid查询检测标准

  3338.                         model = PdtService.GetModelNavByMFID(mfid);

  3339.                         if (model == null)

  3340.                         {

  3341.                             Log("Mes", $"MFID({mfid})对应配方不存在，请先添加产品配方设置！", WarningEnum.Normal);

  3342.                             //弹窗添加配方

  3343.                             MesSelectPdt mesSelectPdt = new MesSelectPdt(mfid);

  3344.                             if (mesSelectPdt.ShowDialog() == DialogResult.OK)

  3345.                             {

  3346.                                 model = PdtService.GetModelNavByMFID(mfid);

  3347.                                 Log("Mes", $"MFID({mfid})绑定配方({model.Name})成功！", WarningEnum.Normal);

  3348.                             }

  3349.                             else

  3350.                             {

  3351.                                 Log("Mes", $"取消绑定，流程结束！", WarningEnum.High);

  3352.                                 return false;

  3353.                             }

  3354.                         }

  3355.                         double t;

  3356.                         cnt = double.TryParse(cnt, out t) ? cnt : "0";

  3357.                     }

  3358.                     else

  3359.                     {

  3360.                         Log("Mes", $"Mes通信失败！{confMgr.SysConfigParams.MesServerAddr}-{mjson}", WarningEnum.High);

  3361.                         return false;

  3362.                     }

  3363.                 }

  3364.                 else

  3365.                 {

  3366.                     if (string.IsNullOrEmpty(name) || name == "未找到")

  3367.                     {

  3368.                         Log("运行", "产品品名为空！", WarningEnum.Low);

  3369.                         return false;

  3370.                     }

  3371.                     if (string.IsNullOrEmpty(DefectName))

  3372.                     {

  3373.                         Log("运行", "检测标准未选择！", WarningEnum.Low);

  3374.                         return false;

  3375.                     }

  3376.                     //if (string.IsNullOrEmpty(batch))

  3377.                     //{

  3378.                     //    Log("运行", "批号为空！", WarningEnum.Low);

  3379.                     //    return false;

  3380.                     //}

  3381.                     //if (string.IsNullOrEmpty(reel))

  3382.                     //{

  3383.                     //    Log("运行", "卷号为空！", WarningEnum.Low);

  3384.                     //    return false;

  3385.                     //}

  3386.                     barCodeName = name;

  3387.                     batchId = batch;

  3388.                     reelId = reel;

  3389.                     double t;

  3390.                     cnt = double.TryParse(cnt, out t) ? cnt : "0";

  3391.                     model = PdtService.GetModelNavByName(DefectName);

  3392.                 }

  3393.                 if (model == null)

  3394.                 {

  3395.                     Log("扫码", $"编码({sn})对应配方不存在，请先添加产品配方设置，暂停设备！", WarningEnum.High);

  3396.                     return false;

  3397.                 }

  3398.                 DefectName = model.Name;

  3399. 

  3400.                 //数据处理

  3401.                 Records record;

  3402.                 lock (lockCurrKey)

  3403.                 {

  3404.                     errStep = 3;

  3405.                     //保存，这里队列图片可能还未检测完 

  3406.                     if (currKey > 0)

  3407.                     {

  3408.                         string szBatchId, szReelId;

  3409.                         double ldErpLen;

  3410.                         szBatchId = batch;

  3411.                         szReelId = reel;

  3412.                         ldErpLen = Convert.ToDouble(cnt);

  3413.                         //BatchId = code,//code[2]

  3414.                         //ReelId = "1",//code[3]

  3415.                         int mykey = currKey;

  3416.                         //Task.Run(() => { saveCurrRecord(mykey); });

  3417.                         saveCurrRecord(mykey);

  3418.                         currKey = 0;

  3419.                     }

  3420. 

  3421.                     errStep = 4;

  3422.                     var now = DateTime.Now;

  3423.                     currKey = now.Hour * 10000 + now.Minute * 100 + now.Second;

  3424.                     //var materialItem =  codes[0]+"-"+ codes[1];

  3425.                     //var colorItem = Config.getColorItem(int.Parse(codes[2]));

  3426.                     record = new Records()

  3427.                     {

  3428.                         currKey = currKey,

  3429.                         ProductId = model.Id,

  3430.                         ProductInfo = model,//后面计算合格时用

  3431.                         Color = model.ColorName,

  3432.                         Material = model.Material,//codes[0] + "-" + codes[1],// (materialItem == null ? "未知" : materialItem["name"].ToString()), 

  3433.                         BarCode = sn,

  3434.                         BarCodeName = barCodeName,

  3435.                         ErpLen = double.Parse(len),

  3436.                         BatchId = batchId,

  3437.                         ReelId = reelId,

  3438.                         ModifyUserCode = userMgr.LoginUser.Code,

  3439.                         CreateUserCode = userMgr.LoginUser.Code,

  3440.                     };

  3441.                     htTask.Add(currKey, record);

  3442.                 }

  3443.                 errStep = 8;

  3444.                 // 

  3445.                 errStep = 9;

  3446.                 Log("扫码", $"品名({barCodeName})，条码({sn})，加载产品信息({model.Code})完成，加载配方(光源={model.LightValue},曝光={model.ExposureTime},增益={model.Gain})...");

  3447.                 errStep = 10;

  3448. #if Online

  3449.                 if (model.LightValue > 0)//光源 - 通道0

  3450.                     lightDev.SetLightDigitalValue(1, model.LightValue);

  3451.                 errStep = 11;

  3452.                 if (model.ExposureTime > 0 || model.Gain > 0)//相机曝光 增益

  3453.                 {

  3454.                     LineCamDev1.SetExposure((float)(model.ExposureTime > 0 ? model.ExposureTime : 0));

  3455.                     LineCamDev1.SetGain((float)(model.Gain > 0 ? model.Gain : 0));

  3456. 

  3457.                     LineCamDev2.SetExposure((float)(model.ExposureTime > 0 ? model.ExposureTime : 0));

  3458.                     LineCamDev2.SetGain((float)(model.Gain > 0 ? model.Gain : 0));

  3459.                 }

  3460. #endif

  3461.                 errStep = 15;

  3462.                 Log("扫码", $"品名({barCodeName})，配方设置完成:光源={model.LightValue},曝光={model.ExposureTime}");

  3463. 

  3464.                 //显示二次判定项和打标项

  3465.                 OnAutoRuning(new RunEventArgs(model));

  3466.                 //加载所有二次判断

  3467. 

  3468.                 //显示光源亮度

  3469.                 OnAutoRuning(new RunEventArgs(model.LightValue));

  3470.                 //计米器清空

  3471. #if Online

  3472.                 ClearLengthCount();

  3473. #endif

  3474.                 JmFtStart = false;

  3475.                 Thread.Sleep(1000);

  3476. 

  3477.                 //启动ai寻边模型

  3478.                 if (confMgr.SysConfigParams.OpenAIEdge)

  3479.                 {

  3480.                     Log("加载", $"加载ai寻边模型");

  3481.                     OpencvUtils.LoadEdgeMode();

  3482.                 }

  3483.                 //清空相机内存

  3484.                 LineCamDev1.ClearImageQueue();

  3485.                 LineCamDev2.ClearImageQueue();

  3486.                 //if(LineCamDev1.ClearImageQueue())

  3487.                 //{

  3488.                 //    Log("内存", $"相机1清空内存失败！", WarningEnum.High);

  3489.                 //    return false;

  3490.                 //}

  3491.                 //if (LineCamDev2.ClearImageQueue())

  3492.                 //{

  3493.                 //    Log("内存", $"相机2清空内存失败！", WarningEnum.High);

  3494.                 //    return false;

  3495.                 //}

  3496.                 //判断是否已经有同名称产品存图

  3497.                 ImgDirSN = DateTime.Now.ToString("HHmmss");

  3498.               

  3499. 

  3500.                 pStopWatch.Restart();

  3501.                 pRunSpeedWatch.Restart();

  3502.                 //清空安全队列

  3503.                 ScanPhotoInfo tryDe;

  3504.                 while (_matList1.TryDequeue(out tryDe))

  3505.                 {

  3506.                     Thread.Sleep(10);

  3507.                 }

  3508.                 while (_matList2.TryDequeue(out tryDe))

  3509.                 {

  3510.                     Thread.Sleep(10);

  3511.                 }

  3512.                 _isHaveImgL = false;

  3513.                 _isHaveImgR = false;

  3514. 

  3515.                 _marginWidth1 = 0;

  3516.                 _marginWidth2 = 0;

  3517. 

  3518.                 _DefectEnd = 0;

  3519.                 _NarmalWidth = 0;

  3520.                 Cam1Cnt = 0;

  3521.                 Cam2Cnt = 0;

  3522.  

  3523.                 defectPuaseList.Clear();

  3524.                 defectPuaseImgList.Clear();

  3525. 

  3526.                 System.GC.Collect();

  3527.                 errStep = 16;

  3528.                 LedRun();

  3529.                 _isRuning = true;

  3530.                 _isAuto = true;

  3531.                 statusMgr.GotoAuto();

  3532.                 SendStatus();

  3533.                 CurrProductModel = model;

  3534.                 

  3535.                 //获取模型label

  3536.                 GetDefectAllLabel();

  3537. 

  3538.                 //电机启动

  3539.                 StartMotion();

  3540.             }

  3541.             catch (Exception ex)

  3542.             {

  3543.                 Log("运行", $"程序错误-{errStep}:" + ex.Message + "\n", WarningEnum.High);

  3544.             }

  3545. 

  3546.             return ret;

  3547.         }

  3548.         /// <summary>

  3549.         /// 暂停重启

  3550.         /// </summary>

  3551.         /// <returns></returns>

  3552.         public bool ReStartRun()

  3553.         {

  3554.             bool ret = false;

  3555. 

  3556.             Log("启动", "下发启动指令...");

  3557.             if (confMgr.SysConfigParams.OpenPLC)

  3558.             {

  3559.                 if (plcDev.IsInit())

  3560.                 {

  3561.                     plcDev.WriteCoil("DB3.DBX0.1", false);

  3562.                     plcDev.WriteCoil("DB3.DBX0.0", true);//启动

  3563.                 }

  3564.                 else

  3565.                 {

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

  3567.                     return false;

  3568.                 }

  3569.             }

  3570.             else if (confMgr.SysConfigParams.OpenIO)

  3571.             {

  3572.                 bool sts;

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

  3574.                 if (!sts)

  3575.                 {

  3576.                     ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动 ), GetIOBitIndex((int)DOName.启动), true);

  3577.                     Task.Run(async () =>

  3578.                     {

  3579.                         await Task.Delay(500);

  3580.                         ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动), GetIOBitIndex((int)DOName.启动), false);

  3581.                     });

  3582.                 }

  3583.             }

  3584. 

  3585.             pStopWatch.Start();

  3586.             pRunSpeedWatch.Start();

  3587.             Log("启动", $"暂停 -> 继续");

  3588.             LedRun();

  3589.             _isRuning = true;

  3590.             statusMgr.GotoAuto();

  3591.             SendStatus();

  3592.             ret = true;

  3593.             

  3594.             return ret;

  3595.         }

  3596. #endregion

  3597. 

  3598.         #region 文件删除

  3599.         public void DelectPictureFile()

  3600.         {

  3601.             //删除文件

  3602.             Task.Factory.StartNew(() =>

  3603.             {

  3604.                 //图片

  3605.                 if (confMgr.SysConfigParams.DefectSrcImag.AutoDelete)

  3606.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSrcImag.SavePath, confMgr.SysConfigParams.DefectSrcImag.AutoDeleteDays, true);

  3607.                 if (confMgr.SysConfigParams.DefectSmallImag.AutoDelete)

  3608.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSmallImag.SavePath, confMgr.SysConfigParams.DefectSmallImag.AutoDeleteDays, true);

  3609.                 if (confMgr.SysConfigParams.DefectSplicImag.AutoDelete)

  3610.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSplicImag.SavePath, confMgr.SysConfigParams.DefectSplicImag.AutoDeleteDays, true);

  3611.                 if (confMgr.SysConfigParams.CamImag.AutoDelete)

  3612.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.CamImag.SavePath, confMgr.SysConfigParams.CamImag.AutoDeleteDays, true);

  3613. 

  3614.                 //日志

  3615.                 if (confMgr.SysConfigParams.AutoDeleteLog)

  3616.                     statusMgr.DeleteFiles(confMgr.SysConfigParams.LogPath, confMgr.SysConfigParams.AutoDeleteLogData, true);

  3617.             });

  3618.         }

  3619. 

  3620.         #region 数据保存

  3621.        

  3622.         private async void saveCurrRecord(int key)

  3623.         {

  3624.             Records model = null;

  3625.             int step = 0;

  3626.             try

  3627.             {

  3628.                 _isDefect = true;

  3629.                 Log( "入库", $"准备入库key={key}");

  3630.                 //foreach (int itemKey in htTask.Keys) 

  3631.                 //    AddTextEvent(DateTime.Now,"入库", $"htTask {itemKey}");

  3632. 

  3633.                 step = 1;

  3634.                 model = Hashtable.Synchronized(htTask)[key] as Records;

  3635.                 //model = htTask[key] as Records;

  3636.                 step = 2;

  3637.                 if (model.Len == 0)

  3638.                 {

  3639.                     Log("入库完成", $"小于1米不记录");

  3640.                     _isDefect = false;

  3641.                     return;

  3642.                 }

  3643. 

  3644.                 //model.BatchId = batchId;

  3645.                 //model.ReelId = reelId;

  3646.                 //model.ErpLen = erpLen;

  3647.                 while (model.ScannerPhotoCount > model.ScannerPhotoFinishCount)

  3648.                     await Task.Delay(100);

  3649.                 step = 3;

  3650.                 //计算等级标准

  3651.                 List<GradeLimit> gradeLimitList = model.ProductInfo.GradeLimitList;

  3652.                 if (gradeLimitList != null && gradeLimitList.Count > 0)

  3653.                 {

  3654.                     step = 4;

  3655.                     int count;

  3656.                     foreach (GradeLimit item in gradeLimitList)

  3657.                     {

  3658.                         if (item.A == 0 && item.B == 0 && item.C == 0 && item.D == 0 && item.E == 0)

  3659.                         {

  3660.                             count = model.DefectInfoList.Where(m => m.Code == item.Code).Count();

  3661.                             model.Grade = 1;

  3662.                             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}]");

  3663.                         }

  3664.                         else

  3665.                         {

  3666.                             if (model.DefectInfoList != null && model.DefectInfoList.Count > 0)

  3667.                             {

  3668.                                 count = model.DefectInfoList.Where(m => m.Code == item.Code).Count();

  3669.                                 if (count <= item.A && model.Grade <= 1) model.Grade = 1;

  3670.                                 else if (count <= item.B && item.B > 0 && model.Grade <= 2) model.Grade = 2;

  3671.                                 else if (count <= item.C && item.C > 0 && model.Grade <= 3) model.Grade = 3;

  3672.                                 else if (count <= item.D && item.D > 0 && model.Grade <= 4) model.Grade = 4;

  3673.                                 else if (count <= item.E && item.E > 0 && model.Grade <= 5) model.Grade = 5;

  3674.                                 else if (count > 0) model.Grade = 6;//不合格

  3675.                                 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}]");

  3676.                             }

  3677.                             else

  3678.                             {

  3679.                                 model.Grade = 1;

  3680.                                 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}]");

  3681.                             }

  3682.                         }

  3683.                     }

  3684.                     step = 5;

  3685.                 }

  3686.                 model.Qualified = (model.Grade < 6);//是否合格

  3687.                 if (!RecordService.InsertNav(model))

  3688.                     throw new Exception("写库失败！");

  3689.                 Log("入库完成", $"({key}) 条码({model.BarCode})已完成检测-{model.ScannerPhotoCount}-{model.ScannerPhotoFinishCount}。");

  3690.                 htTask.Remove(key);

  3691.                 _isDefect = false;

  3692.             }

  3693.             catch (Exception ex)

  3694.             {

  3695.                 _isDefect = false;

  3696.                 if (model == null) 

  3697.                     Log("入库失败", $"记录({key})不存在{step}！" + ex.Message, WarningEnum.High);

  3698.                 else 

  3699.                     Log("入库失败", $"({key}) 条码({model.BarCode})检测完成,但保存检测记录失败{step}:" + ex.Message, WarningEnum.High);

  3700.             }

  3701.         }

  3702.         #endregion

  3703. 

  3704.         #endregion

  3705. 

  3706.         #region 表格事件查询

  3707.         public DefectInfo GetDefectInfo(long uid)

  3708.         {

  3709.             if (currKey == 0)

  3710.                 return null;

  3711.             Records record = Hashtable.Synchronized(htTask)[currKey] as Records;

  3712.             //var defectInfo = record.DefectInfoList[record.DefectInfoList.Count - e.RowIndex-1];//按顺序索引引用

  3713.             var defectInfo = record.DefectInfoList.FirstOrDefault(m => m.uid == uid);

  3714.             return defectInfo;

  3715.         }

  3716.         #endregion

  3717. 

  3718.         #region 拷贝产品

  3719.         /// <summary>

  3720.         /// 拷贝产品

  3721.         /// </summary>

  3722.         /// <param name="list"></param>

  3723.         /// <param name="liIndex"></param>

  3724.         /// <param name="stepID">流程ID</param>

  3725.         /// <param name="stepInfo">流程</param>

  3726.         /// <returns></returns>

  3727.         public bool ProductCopy(List<Product> list, int liIndex)

  3728.         {

  3729.             Product newProduct = new Product()

  3730.             {

  3731.                 Code = list[liIndex].Code + "_clone",

  3732.                 Name = $"{list[liIndex].Name} (克隆)",

  3733.                 Spec = list[liIndex].Spec,

  3734.                 Material = list[liIndex].Material,

  3735.                 Color = list[liIndex].Color,

  3736.                 ColorName = list[liIndex].ColorName,

  3737.                 ColorValue = list[liIndex].ColorValue,

  3738.                 LightValue = list[liIndex].LightValue,

  3739.                 ExposureTime = list[liIndex].ExposureTime,

  3740. 

  3741.                 Gain = list[liIndex].Gain,

  3742.                 TensionValue = list[liIndex].TensionValue,

  3743.                 Note = list[liIndex].Note,      

  3744.                 ModelName = list[liIndex].ModelName,

  3745.                 DefectAreaLimit = list[liIndex].DefectAreaLimit,

  3746.                 DefectCountLimit = list[liIndex].DefectCountLimit,

  3747.                 DefectPauseForUser = list[liIndex].DefectPauseForUser,

  3748.                 DefectCntLength = list[liIndex].DefectCntLength,

  3749.                 WarnDefect = list[liIndex].WarnDefect,

  3750.                 OpenThicknessDetection = list[liIndex].OpenThicknessDetection,

  3751.                 ThicknessDetectionStopDis = list[liIndex].ThicknessDetectionStopDis,

  3752.                 residueWarnningLen = list[liIndex].residueWarnningLen,

  3753. 

  3754.                 QualifiedLimitList = new List<QualifiedLimit>(),

  3755.                 GradeLimitList = new List<GradeLimit>(),

  3756.                 DefectPauseOption = list[liIndex].DefectPauseOption,

  3757.                 //OrderList = new List<Order>(),

  3758. 

  3759.                 ModifyUserCode = userMgr.LoginUser.Code,

  3760.                 CreateUserCode = userMgr.LoginUser.Code

  3761.             };

  3762.             foreach (var item in list[liIndex].QualifiedLimitList)

  3763.             {

  3764.                 newProduct.QualifiedLimitList.Add(new QualifiedLimit()

  3765.                 {

  3766.                     Code = item.Code,

  3767.                     ZXD = item.ZXD,

  3768.                     Pid = item.Pid,

  3769.                     Name = item.Name,

  3770.                     Area = item.Area,

  3771.                     ContrastTop = item.ContrastTop,

  3772.                     ContrastLower = item.ContrastLower,

  3773. 

  3774.                     IsOR = item.IsOR,

  3775.                     NameCode = item.NameCode,

  3776.                     DefectWarnLength = item.DefectWarnLength,

  3777.                     DefectWarnCnt = item.DefectWarnCnt,

  3778. 

  3779.                     ModifyUserCode = userMgr.LoginUser.Code,

  3780.                     CreateUserCode = userMgr.LoginUser.Code

  3781.                 });

  3782.             }

  3783.             foreach (var item in list[liIndex].GradeLimitList)

  3784.             {

  3785.                 newProduct.GradeLimitList.Add(new GradeLimit()

  3786.                 {

  3787.                     Pid = item.Pid,

  3788.                     Code = item.Code,

  3789.                     A = item.A,

  3790.                     B = item.B,

  3791.                     C = item.C,

  3792.                     D = item.D,

  3793.                     E = item.E,

  3794. 

  3795.                     ModifyUserCode = userMgr.LoginUser.Code,

  3796.                     CreateUserCode = userMgr.LoginUser.Code

  3797.                 });

  3798.             }

  3799.             

  3800.             bool result = PdtService.InsertNav(newProduct);

  3801. 

  3802.             return result;

  3803.         }

  3804.         #endregion

  3805. 

  3806.         #region 加载二次判定项

  3807.         /// <summary>

  3808.         /// 二次项判断名称列表

  3809.         /// </summary>

  3810.         private List<string> DefectItemsPuaseNameList = new List<string>();

  3811.         public void LoadDefectItemsPuase(List<string> list)

  3812.         {

  3813.             DefectItemsPuaseNameList.Clear();

  3814.             foreach (var item in list)

  3815.             {

  3816.                 DefectItemsPuaseNameList.Add(item);

  3817.             }

  3818.             

  3819.         }

  3820.         #endregion

  3821. 

  3822.         #region 二次判断完成修改

  3823.         public Product GetProduct(string name)

  3824.         {

  3825.             return PdtService.GetModelNavByName(name);

  3826.         }

  3827.         /// <summary>

  3828.         /// 删除忽略项

  3829.         /// </summary>

  3830.         /// <param name="curRecord"></param>

  3831.         /// <param name="lstDel"></param>

  3832.         public void DelDefectEdit(Records curRecord, List<DefectInfo> lstDel)

  3833.         {

  3834.             foreach (var item in lstDel)

  3835.             {

  3836.                 curRecord.DefectInfoList.Remove(item);

  3837.                 

  3838.             }

  3839.         }

  3840.         #endregion

  3841. 

  3842.         #region 颜色判断

  3843.         

  3844.         /// <summary>

  3845.         /// 根据RGB判断颜色

  3846.         /// </summary>

  3847.         /// <param name="Clr"></param>

  3848.         /// <returns></returns>

  3849.         public static string CLRToName(System.Drawing.Color Clr)

  3850.         {

  3851.             double d_r = (double)Clr.R / 83;

  3852.             double d_g = (double)Clr.G / 83;

  3853.             double d_b = (double)Clr.B / 83;

  3854.             int r = (int)Math.Round(d_r);

  3855.             int g = (int)Math.Round(d_g);

  3856.             int b = (int)Math.Round(d_b);

  3857.             string rgb = r.ToString() + "," + g.ToString() + "," + b.ToString();

  3858.             #region "switch (rgb)"

  3859.             switch (rgb)

  3860.             {

  3861.                 case "0,0,0":

  3862.                 case "1,1,1":

  3863.                 case "2,2,2":

  3864.                 case "3,3,3":

  3865.                     if (r == 0) return RGBName.Black.GetDescription();

  3866.                     if (r == 1) return RGBName.Gray.GetDescription();

  3867.                     if (r == 2) return RGBName.LightGray.GetDescription();

  3868.                     if (r == 3) return RGBName.White.GetDescription();

  3869.                     break;

  3870.                 case "0,0,3":

  3871.                 case "0,3,0":

  3872.                 case "3,0,0":

  3873.                 case "1,1,3":

  3874.                 case "1,3,1":

  3875.                 case "3,1,1":

  3876.                 case "0,1,3":

  3877.                 case "0,3,1":

  3878.                 case "3,0,1":

  3879.                 case "1,0,3":

  3880.                 case "1,3,0":

  3881.                 case "3,1,0":

  3882.                 case "0,0,2":

  3883.                 case "0,2,0":

  3884.                 case "2,0,0":

  3885.                 case "1,1,2":

  3886.                 case "1,2,1":

  3887.                 case "2,1,1":

  3888.                 case "0,1,2":

  3889.                 case "0,2,1":

  3890.                 case "2,0,1":

  3891.                 case "1,0,2":

  3892.                 case "1,2,0":

  3893.                 case "2,1,0":

  3894.                     if (r == 2) return RGBName.DarkRed.GetDescription();

  3895.                     if (g == 2) return RGBName.DarkGreen.GetDescription();

  3896.                     if (b == 2) return RGBName.DarkBlue.GetDescription();

  3897.                     if (r == 3) return RGBName.Red.GetDescription();

  3898.                     if (g == 3) return RGBName.Green.GetDescription();

  3899.                     if (b == 3) return RGBName.Blue.GetDescription();

  3900.                     break;

  3901.                 case "0,0,1":

  3902.                 case "0,1,0":

  3903.                 case "1,0,0":

  3904.                 case "2,2,3":

  3905.                 case "2,3,2":

  3906.                 case "3,2,2":

  3907.                     if (r == 1) return RGBName.DarkRed.GetDescription();

  3908.                     if (g == 1) return RGBName.DarkGreen.GetDescription();

  3909.                     if (b == 1) return RGBName.DarkBlue.GetDescription();

  3910.                     if (r == 3) return RGBName.LightRed.GetDescription();

  3911.                     if (g == 3) return RGBName.LightGreen.GetDescription();

  3912.                     if (b == 3) return RGBName.LightBlue.GetDescription();

  3913.                     break;

  3914.                 case "1,1,0":

  3915.                 case "0,1,1":

  3916.                 case "1,0,1":

  3917.                 case "2,2,0":

  3918.                 case "0,2,2":

  3919.                 case "2,0,2":

  3920.                 case "2,2,1":

  3921.                 case "1,2,2":

  3922.                 case "2,1,2":

  3923.                 case "3,3,0":

  3924.                 case "0,3,3":

  3925.                 case "3,0,3":

  3926.                 case "3,3,1":

  3927.                 case "1,3,3":

  3928.                 case "3,1,3":

  3929.                 case "3,3,2":

  3930.                 case "2,3,3":

  3931.                 case "3,2,3":

  3932.                     if (r == 1 && g == 1) return RGBName.DarkYellow.GetDescription();

  3933.                     if (g == 1 && b == 1) return RGBName.DarkCyan.GetDescription();

  3934.                     if (r == 1 && b == 1) return RGBName.DarkPurple.GetDescription();

  3935.                     if (r == 2 && g == 2) return RGBName.Yellow.GetDescription();

  3936.                     if (g == 2 && b == 2) return RGBName.Cyan.GetDescription();

  3937.                     if (r == 2 && b == 2) return RGBName.Purple.GetDescription();

  3938.                     if (r == 3 && g == 3) return RGBName.LightYellow.GetDescription();

  3939.                     if (g == 3 && b == 3) return RGBName.LightCyan.GetDescription();

  3940.                     if (r == 3 && b == 3) return RGBName.LightPurple.GetDescription();

  3941.                     break;

  3942.                 case "3,2,0":

  3943.                 case "3,2,1":

  3944.                     return RGBName.Orange.GetDescription();

  3945.                 case "2,3,0":

  3946.                 case "2,3,1":

  3947.                     return RGBName.YellowGreen.GetDescription();

  3948.                 case "0,3,2":

  3949.                 case "1,3,2":

  3950.                     return RGBName.CyanGreen.GetDescription();

  3951.                 case "0,2,3":

  3952.                 case "1,2,3":

  3953.                     return RGBName.CyanBlue.GetDescription();

  3954.                 case "3,0,2":

  3955.                 case "3,1,2":

  3956.                     return RGBName.PurpleRed.GetDescription();

  3957.                 case "2,0,3":

  3958.                 case "2,1,3":

  3959.                     return RGBName.PurpleBlue.GetDescription();

  3960.                 default:

  3961.                     return "Error";

  3962.             }

  3963.             #endregion

  3964.             return "Error";

  3965.         }

  3966. 

  3967.         #endregion

  3968. 

  3969.         #region 博艺Mes

  3970.         public class MesCode

  3971.         {

  3972.             /// <summary>

  3973.             /// 类型

  3974.             /// </summary>

  3975.             public string sProName { get; set; }

  3976.             /// <summary>

  3977.             /// 

  3978.             /// </summary>

  3979.             public string sJson { get; set; }

  3980.         }

  3981. 

  3982.         public class MesReturnCode

  3983.         {

  3984.             public string FID { get; set; }

  3985.             public string PCode { get; set; }

  3986.             public string MFID { get; set; }

  3987.             public string Mname { get; set; }

  3988.             public string PColor { get; set; }

  3989.             public string RawMFid { get; set; }

  3990.             public string RawMName { get; set; }

  3991.             public string PPaper { get; set; }

  3992.             public string PQty { get; set; }

  3993.             public string PDDate { get; set; }

  3994.             public string PDes { get; set; }

  3995.             public string CtmFid { get; set; }

  3996.             public string CtmName { get; set; }

  3997.         }

  3998.         public class Root

  3999.         {

  4000.             /// <summary>

  4001.             /// 

  4002.             /// </summary>

  4003.             public List<ListItem> List { get; set; }

  4004.         }

  4005.         private string GetMesJson(string code)

  4006.         { 

  4007.             MesCode mesCode = new MesCode();

  4008.             mesCode.sProName = "API_GetPrdTaskItm";

  4009.             mesCode.sJson = code;

  4010.             string jsonstr = JsonConvert.SerializeObject(mesCode);

  4011.             return jsonstr;

  4012.         }

  4013. 

  4014.         private bool MesReturn(string json, out string MFID, out string httprel)

  4015.         {

  4016.             MFID = "";

  4017.             httprel = "";

  4018.             if (string.IsNullOrEmpty(confMgr.SysConfigParams.MesServerAddr))

  4019.                 return false;

  4020.            

  4021.                 string url = confMgr.SysConfigParams.MesServerAddr;

  4022.                 string data = json;

  4023.                 httprel = HttpApi.Post(url, HttpApi.HttpContentType.application_json, data);

  4024.                 if (string.IsNullOrEmpty(httprel))

  4025.                     return false;

  4026.                 JObject Param = JObject.Parse(httprel);

  4027. 

  4028.                 MFID = Param["List"][0]["MFID"].ToString();

  4029. 

  4030. 

  4031.                 if (string.IsNullOrEmpty(MFID))

  4032.                     return false;

  4033.                 return true;

  4034. 

  4035.         }

  4036.         #endregion

  4037. 

  4038.         #region 特殊记录

  4039.         public void LogMeg(string mesg)

  4040.         {

  4041.             Log("界面记录", mesg, WarningEnum.Normal, false);

  4042.         }

  4043.         #endregion

  4044.     }

  4045.     #region 系统事件

  4046.     /// <summary>

  4047.     /// 流程事件

  4048.     /// </summary>

  4049.     public class RunEventArgs : EventArgs

  4050.     {

  4051.         private int _cmd;

  4052.         public int Cmd { get { return _cmd; } }

  4053. 

  4054.         private int _picIndex;

  4055.         public int PicIndex { get { return _picIndex; } }

  4056.         private Mat _pic;

  4057.         public Mat Pic { get { return _pic; } }

  4058.         public RunEventArgs(int index, Mat pic)

  4059.         {

  4060.             this._cmd = 6;

  4061.             this._picIndex = index;

  4062.             this._pic = pic.Clone();

  4063.         }

  4064. 

  4065.         private bool _over;

  4066.         public bool Over { get { return _over; } }

  4067.         public RunEventArgs(bool ov)

  4068.         {

  4069.             this._cmd = 10;

  4070.             this._over = ov;

  4071.         }

  4072. 

  4073.         private List<object[]> _dataRowlist = new List<object[]>();

  4074.         public List<object[]> DataRowlist { get { return _dataRowlist; } }

  4075.         public RunEventArgs(List<object[]> dataRowlist)

  4076.         {

  4077.             this._cmd = 11;

  4078.             this._dataRowlist = dataRowlist;

  4079.         }

  4080. 

  4081.         private Image _defectimg;

  4082.         public Image Defectimg { get { return _defectimg; } }

  4083.         public RunEventArgs(Image defectimg)

  4084.         {

  4085.             this._cmd = 12;

  4086.             this._defectimg = defectimg;

  4087.         }

  4088. 

  4089.         private List<float[]> _points;

  4090.         public List<float[]> Points { get { return _points; } }

  4091.         public RunEventArgs(List<float[]> pints)

  4092.         {

  4093.             this._cmd = 13;

  4094.             this._points = pints;

  4095.         }

  4096. 

  4097.         private double _len;

  4098.         public double Len { get { return _len; } }

  4099.         private double _speed;

  4100.         public double Speed { get { return _speed; } }

  4101.         public RunEventArgs(double len, double spd)

  4102.         {

  4103.             this._cmd = 14;

  4104.             this._len = len;

  4105.             this._speed = spd;

  4106.         }

  4107. 

  4108.         private Mat _Matimg;

  4109.         public Mat DefectMat { get { return _Matimg; } }

  4110.         public RunEventArgs(Mat defectimg)

  4111.         {

  4112.             this._cmd = 15;

  4113.             this._Matimg = defectimg.Clone();

  4114.             //this._Matimg = defectimg;

  4115.         }

  4116. 

  4117.         private int _cam1ImgCnt;

  4118.         public int Cam1ImgCnt { get { return _cam1ImgCnt; } }

  4119.         private int _cam2ImgCnt;

  4120.         public int Cam2ImgCnt { get { return _cam2ImgCnt; } }

  4121.         private int _defectImgCnt;

  4122.         public int DeefectImgCnt { get { return _defectImgCnt; } }

  4123.         private int _saveImgCnt;

  4124.         public int SaveImgCnt { get { return _saveImgCnt; } }

  4125. 

  4126.         private string _definfoCnt;

  4127.         public string _DefinfoCnt { get { return _definfoCnt; } }

  4128.         public RunEventArgs(int cnt1, int cnt2, string definfo)

  4129.         {

  4130.             this._cmd = 16;

  4131.             this._cam1ImgCnt = cnt1;

  4132.             this._cam2ImgCnt = cnt2;

  4133.             this._definfoCnt = definfo;

  4134.         }

  4135. 

  4136.         public RunEventArgs(int cnt1, int cnt2, int cnt3)

  4137.         {

  4138.             this._cmd = 20;

  4139.             //this._cam1ImgCnt = cnt1;

  4140.             //this._cam2ImgCnt = cnt2;

  4141.             this._saveImgCnt = cnt3;

  4142.         }

  4143. 

  4144.         private int _lightValue;

  4145.         public int LightValue { get { return _lightValue; } }

  4146.         public RunEventArgs(int val)

  4147.         {

  4148.             this._cmd = 17;

  4149.             this._lightValue = val;

  4150.         }

  4151. 

  4152.         private Product _md;

  4153.         public Product MD { get { return _md; } }

  4154.         public RunEventArgs(Product md)

  4155.         {

  4156.             this._cmd = 18;

  4157.             this._md = md;

  4158.         }

  4159. 

  4160.         private int _imgIndex;

  4161.         public int ImgIndex { get { return _imgIndex; } }

  4162. 

  4163.         private List<DefectInfo> _lstEditDefect;

  4164.         public List<DefectInfo> LstEditDefect { get { return _lstEditDefect; } }

  4165. 

  4166.         private List<DefectInfo> _lstEditInfo;

  4167.         public List<DefectInfo> LstEditInfo { get { return _lstEditInfo; } }

  4168. 

  4169.         private Records _records;

  4170.         public Records Records { get { return _records; } }

  4171. 

  4172.         private Mat _tagImg;

  4173.         public Mat TagImg { get { return _tagImg; } }

  4174.         public RunEventArgs(int index, List<DefectInfo> lstEditDefect, Records currRecord, Mat img, List<DefectInfo> lstEditInfo)

  4175.         {

  4176.             this._cmd = 19;

  4177.             this._imgIndex = index;

  4178.             this._lstEditDefect = lstEditDefect;

  4179.             this._records = currRecord;

  4180.             this._tagImg = img;

  4181.             this._lstEditInfo = lstEditInfo;

  4182.         }

  4183. 

  4184.         public RunEventArgs(int index, List<DefectInfo> lstEditDefect, Records currRecord, Mat img)

  4185.         {

  4186.             this._cmd = 21;

  4187.             this._imgIndex = index;

  4188.             this._lstEditDefect = lstEditDefect;

  4189.             this._records = currRecord;

  4190.             this._tagImg = img;

  4191.         }

  4192.     }

  4193.     /// <summary>

  4194.     /// 主窗体事件

  4195.     /// </summary>

  4196.     public class MainEventArgs : EventArgs

  4197.     {

  4198.         private string _tag;

  4199.         public string Tag { get { return _tag; } }

  4200. 

  4201.         private string _message;

  4202.         public string Message { get { return _message; } }

  4203. 

  4204.         private int _showIndex;

  4205.         public int ShowIndex { get { return _showIndex; } }

  4206. 

  4207.         private WarningEnum _warning;

  4208.         public WarningEnum Warning { get { return _warning; } }

  4209. 

  4210.         private bool _show;

  4211.         public bool show {  get { return _show; } }

  4212.         public MainEventArgs(int index)

  4213.         {

  4214.             this._showIndex = index;

  4215.             this._show = true;

  4216.         }

  4217.         public MainEventArgs(int index, string message)

  4218.         {

  4219.             this._message = message;

  4220.             this._showIndex = index;

  4221.             this._show = true;

  4222.         }

  4223.         public MainEventArgs(string tag, string message, WarningEnum warning = WarningEnum.Normal)

  4224.         {

  4225.             this._tag = tag;

  4226.             this._message = message;

  4227.             this._showIndex = 0;

  4228.             this._warning = warning;

  4229.             this._show = true;

  4230.         }

  4231.         public MainEventArgs(string tag, string message, WarningEnum warning = WarningEnum.Normal, bool Show = true)

  4232.         {

  4233.             this._tag = tag;

  4234.             this._message = message;

  4235.             this._showIndex = 0;

  4236.             this._warning = warning;

  4237.             this._show = Show;

  4238.         }

  4239.     }

  4240.     /// <summary>

  4241.     /// 初始化事件

  4242.     /// </summary>

  4243.     public class InitEventArgs : EventArgs

  4244.     {

  4245.         private string _message;

  4246.         public string Message { get { return _message; } }

  4247. 

  4248.         private bool _isInitialized;

  4249.         public bool IsInitialized { get { return _isInitialized; } }

  4250.         public InitEventArgs()

  4251.         {

  4252. 

  4253.         }

  4254.         public InitEventArgs(string message, bool isInitialized = false)

  4255.         {

  4256.             this._message = message;

  4257.             this._isInitialized = isInitialized;

  4258.         }

  4259.     }

  4260.     #endregion

  4261. 

  4262.     #region 颜色定义

  4263.     public enum RGBName

  4264.     {

  4265.         [Description("红")]

  4266.         Red = 1,

  4267.         [Description("绿")]

  4268.         Green,

  4269.         [Description("蓝")]

  4270.         Blue,

  4271.         [Description("深红")]

  4272.         DarkRed,

  4273.         [Description("深绿")]

  4274.         DarkGreen,

  4275.         [Description("深蓝")]

  4276.         DarkBlue,

  4277.         [Description("浅红")]

  4278.         LightRed,

  4279.         [Description("浅绿")]

  4280.         LightGreen,

  4281.         [Description("浅蓝")]

  4282.         LightBlue,

  4283.         [Description("黄")]

  4284.         Yellow,

  4285.         [Description("青")]

  4286.         Cyan,

  4287.         [Description("紫")]

  4288.         Purple,

  4289.         [Description("深黄")]

  4290.         DarkYellow,

  4291.         [Description("深青")]

  4292.         DarkCyan,

  4293.         [Description("深紫")]

  4294.         DarkPurple,

  4295.         [Description("浅黄")]

  4296.         LightYellow,

  4297.         [Description("浅青")]

  4298.         LightCyan,

  4299.         [Description("浅紫")]

  4300.         LightPurple,

  4301.         [Description("橙")]

  4302.         Orange,

  4303.         [Description("黄绿")]

  4304.         YellowGreen,

  4305.         [Description("青绿")]

  4306.         CyanGreen,

  4307.         [Description("青蓝")]

  4308.         CyanBlue,

  4309.         [Description("紫蓝")]

  4310.         PurpleBlue,

  4311.         [Description("紫红")]

  4312.         PurpleRed,

  4313.         [Description("黑")]

  4314.         Black,

  4315.         [Description("白")]

  4316.         White,

  4317.         [Description("灰")]

  4318.         Gray,

  4319.         [Description("浅灰")]

  4320.         LightGray,

  4321.     }

  4322. 

  4323.     static class EnumExtensions

  4324.     {

  4325.         public static string GetDescription(this Enum val)

  4326.         {

  4327.             var field = val.GetType().GetField(val.ToString());

  4328.             var customAttribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute));

  4329.             return customAttribute == null ? val.ToString() : ((DescriptionAttribute)customAttribute).Description;

  4330.         }

  4331.     }

  4332.     #endregion

  4333. }