banboshi_V2/halftoneproject-master/BanBoShi/SysCtrl/SysMgr.cs

using BarTenderPrint;
using CCWin.SkinClass;
using CCWin.Win32;
using CCWin.Win32.Com;
using CCWin.Win32.Const;
using HalconDotNet;
using HZH_Controls;
using HZH_Controls.Forms;
using ImageToolKits;
using MaiMuAOI.ImageProcessing;
using MaiMuAOI.SysUI.ProcessStep.Prop;
using MaiMuAOI.SysUI.ProductAndStep;
using MaiMuControl.Device;
using MaiMuControl.Device.AxisDev;
using MaiMuControl.Device.AxisDev.Advantech;
using MaiMuControl.Device.AxisDev.PMS;
using MaiMuControl.Device.CamDev;
using MaiMuControl.Device.IOCardDev;
using MaiMuControl.Device.IOCardDev.Advantech;
using MaiMuControl.Device.LightDev;
using MaiMuControl.Device.LightDev.CST;
using MaiMuControl.Device.LightDev.Rsee;
using MaiMuControl.Device.SenSorDev;
using MaiMuControl.Device.SenSorDev.HeightSensor;
using MaiMuControl.Device.SenSorDev.TensionSensor;
using MaiMuControl.SysStatusMgr.CloudMgr;
using MaiMuControl.SysStatusMgr.MqttMgr;
using MaiMuControl.SysStatusMgr.StatusMgr;
using MaiMuControl.SysStatusMgr.UserMgr;
using MaiMuControl.Utils;
using Models;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using OpenCvSharp;
using OpenCvSharp.Flann;
using ProductionControl;
using ProductionControl.UI;
using ProductionControl.UIExtend;
using Service;
using SqlSugar;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Remoting.Lifetime;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
using System.Windows.Forms;
using System.Xml.Linq;
using ToolKits.Disk;
using ToolKits.EnumTool;
using ToolKits.Http;
using ToolKits.mAPI;
using Yolo5;
using static MaiMuAOI.ImageProcessing.DefectLib;
using static MaiMuAOI.ImageProcessing.SizeLib;
using static MaiMuAOI.SysCtrl.SysMgr;
using static MaiMuControl.SysStatusMgr.MqttMgr.MyMqttClient;
using static System.Net.Mime.MediaTypeNames;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;

namespace MaiMuAOI.SysCtrl
{
    /// <summary>
    /// 主系统控制
    /// </summary>
    public class SysMgr
    {
        #region singleton实例化
        private static SysMgr _instance;
        private static readonly object _lock = new object();
        public static SysMgr Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            _instance = new SysMgr();
                        }
                    }
                }
                return _instance;
            }
        }
        #endregion
        
        public CameraEnumType SysUseCamFront = CameraEnumType.MVSCamera_CC;
        public CameraEnumType SysUseCamBack = CameraEnumType.MVSCamera_GENTL;
        public LightDevNameEnum SysUseLight = LightDevNameEnum.CST;
        //主流程
        private Thread _mainThread;
        private CancellationTokenSource _cts;
        /// <summary>
        /// 流程序号
        /// </summary>
        private int CurrProcessIndex = 0;
        /// <summary>
        /// 当前点位号
        /// </summary>
        private int CurrPoinntCount = 0;
        /// <summary>
        /// 总计时
        /// </summary>
        private Stopwatch stopWatch;
        //运动曲线 默认T型 0更快
        public int MotionST = 0;
        public double DefaultSpeed = 200;
        //系统状态
        private StatusMgr statusMgr;
        public StatusMgr StatusMgr { get { return statusMgr; } }
        //用户管理
        private UserMgr userMgr;

        public UserMgr UserMgr { get { return userMgr; } }
        //系统配置管理
        private ConfMgr confMgr;

        //web服务器
        private WebService webService;

        //局域网云端
        private bool init_Cloud;
        private CloudMgr cloudMgr;
        private int DailyOutput;

        //产品数据服务器
        private MyMqttHostServer myMqttHostServer;
        private MyMqttClient myMqttClient;

        //产品列表
        private List<string> productCodeList = new List<string>();
        public List<string> ProductCodeList { get { return productCodeList; } }

        //产品ID列表
        private List<int> productIdList = new List<int>();
        public List<int> ProductIdList { get { return productIdList; } }

        //近期SN列表
        private List<string> productSNList = new List<string>();
        public List<string> ProductSNList { get { return productSNList; } }

        Service.ProductService PdtService;
        Service.OrderService OrderService;
        Service.ClassesService svcClasses;

        //可用步骤
        public static Dictionary<string, string> dicDevType = new Dictionary<string, string>();
        //2023-12-20 新流程步骤
        public static Dictionary<string, string> ProcessType = new Dictionary<string, string>();

        //图像处理
        private DefectLib defectLib;
        public DefectLib DefectLib { get { return defectLib; } }
        private SizeLib sizeLib;
        public SizeLib SizeLib { get { return sizeLib; } }
        private int SizeNGCnt;

        //流程处理
        private ForLib forLib;
        private IFLib ifLib;
        /// <summary>
        /// 当前产品
        /// </summary>
        private Models.Product CurrProductModel = null;
        /// <summary>
        /// 当前料号
        /// </summary>
        private Order order = new Order();

        //产品-厚度base校正点位索引
        private int ProductPT_HeightBaseNum = 0;

        //线宽,张力，厚度，PT
        private List<double> lstTension = new List<double>();
        private List<double> lstHeight = new List<double>();
        private List<double> lstHeightBase = new List<double>();
        private List<double> lstLineWidth = new List<double>();
        private List<double> lstPT = new List<double>();
        private List<double> lstTestData = new List<double>();
        //系统判断是否是新流程
        private bool IsNewStepProcessVel;

        //当前测试结果
        private int CurrStepResult = 0;

        //当前厚度基准是否完成
        private bool IsCurrHeightBase = false;

        //双控按钮信号
        private bool IsGetStartSig = false;

        //自动聚焦参数
        private bool IsAutoFocus { get; set; }
        private double FocusStep { get; set; }
        private double DirStep { get; set; }
        private int DirWaitTime { get; set; }
        private int FocusTimeOut { get; set; }
        //缺陷循环参数
        private double Left_X = 0;
        private double Left_Y = 0;
        private int X_For = 0;
        private int Y_For = 0;
        private int X_For_Index = 0;
        private int Y_For_Index = 0;
        //图纸选点参数
        private int[] CurrAdaqter = new int[9];

        //image.save保存锁，防止多线程报错
        private object ImageSaveObj = new object();
        //2024-03-12 加入打印列表
        private List<PrintInfo> CurrPrintInfos = new List<PrintInfo>();
        //2024-03-26 加入整体工单打印列表
        private List<PrintInfo> CurrOrderPrintInfos = new List<PrintInfo>();

        //2024-03-26 加入尺寸和缺陷禁用快捷键
        private bool SizeEnable;
        private bool DefectEnable;

        //2024-03-26 加入单号检测总数，ok数，ng数
        private int TotalCnt = 0;
        private int CurrDefectIndex = 0;
        private List<Order> CurrDefectOrders = new List<Order>();

        #region 图像显示列表
        private class scannerGBmpLoc
        {
            public scannerGBmpLoc(Mat mat, double xmm, double ymm)
            {
                bmp = mat;
                Xmm = xmm;
                Ymm = ymm;
            }
            public Mat bmp { get; private set; }
            public double Xmm { get; private set; }
            public double Ymm { get; private set; }
        }
        private class scannerCBmpLoc
        {
            public scannerCBmpLoc(string path, double posX, double posY)
            {
                Path = path;
                PosX = posX;
                PosY = posY;
            }
            public scannerCBmpLoc(HObject himg, double posX, double posY)
            {
                Himage = himg;
                PosX = posX;
                PosY = posY;
            }
            public HObject Himage { get; private set; }
            public string Path { get; private set; }
            public double PosX { get; private set; }
            public double PosY { get; private set; }
        }
        private Queue<scannerGBmpLoc> scannerGBmpQueue = new Queue<scannerGBmpLoc>();
        private Queue<scannerCBmpLoc> scannerCBmpQueue = new Queue<scannerCBmpLoc>();
        /// <summary>
        /// 比对失败的图片
        /// </summary>
        private List<Bitmap> lstCompareFailZoomImage = new List<Bitmap>();

        /// <summary>
        /// --333输出变量供后面多个777使用
        /// </summary>
        public HObject contoursAffineTrans1_Out;

        /// <summary>
        /// 对比引索
        /// </summary>
        private int compBmpIndex = 0;//比对777图的索引
        /// <summary>
        /// 对比张数
        /// </summary>
        private int compBmpNum = 0;//比对张数
        /// <summary>
        /// 缺陷处理图片张数
        /// </summary>
        private int defectBmpNum = 0;
        /// <summary>
        /// 缺陷处理结果
        /// </summary>
        private int defectBmpNumResult = 0;
        /// <summary>
        /// 缺陷总不良数
        /// </summary>
        private int AllDefectCount = 0;
        #endregion

        private SysMgr()
        {
            _isInit = false;
            _isRuning = false;
            statusMgr = StatusMgr.Instance;
            confMgr = ConfMgr.Instance;
            //设置本机为主机数据库
            statusMgr.SetMySqlIPaddr("127.0.0.1");
            userMgr = new UserMgr(statusMgr.MySqlIP);
            Service.InitDB.ConnectionString = confMgr.DBConStr;
            PdtService = new Service.ProductService();
            OrderService = new OrderService();
            webService = new WebService();
            svcClasses = new Service.ClassesService();

            init_Cloud = false;
            cloudMgr = new CloudMgr();
            DailyOutput = 0;

            myMqttHostServer = new MyMqttHostServer();
            myMqttClient = new MyMqttClient();

            scannerGBmpQueue = new Queue<scannerGBmpLoc>();
            scannerCBmpQueue = new Queue<scannerCBmpLoc>();
            lstCompareFailZoomImage = new List<Bitmap>();

            MotionST = 0;
            DefaultSpeed = 200; 
            _cts = new CancellationTokenSource();

            SizeEnable = true;
            DefectEnable = true;

            IsNewStepProcessVel = false;
            InitDevDic();
        }
        #region 日志报警
        /// <summary>
        /// 初始化记录报警和显示
        /// </summary>
        /// <param name="tag">标头</param>
        /// <param name="msg">内容</param>
        /// <param name="warning">报警状态</param>
        private void InitLog(string msg, string tag = "初始化", WarningEnum warning = WarningEnum.Normal)
        {
            OnInitRuning(new InitEventArgs(msg));
            statusMgr.GotoWarning(warning, tag, msg);
        }
        /// <summary>
        /// 记录报警和显示
        /// </summary>
        /// <param name="tag">标头</param>
        /// <param name="msg">内容</param>
        /// <param name="warning">报警状态</param>
        private void Log(string tag, string msg, WarningEnum warning = WarningEnum.Normal)
        {
            OnMainRuning(new MainEventArgs(tag, msg, warning));
            statusMgr.GotoWarning(warning, tag, msg);
            //开启云端
            if((init_Cloud)&&(warning != WarningEnum.Normal))
            {
                //上传报警状态和信息
                string statusStr = warning == WarningEnum.Normal ? "正常" : warning == WarningEnum.Low ? "警告":"系统报警" ;
                cloudMgr.SendTopic("device/attributes", $"{{\"status\": \"{statusStr}\",  \"alm\": \"{tag}-{msg}\", " +
                $"\"name\": \"{confMgr.SysConfigParams.CloudThisName}\", \"DailyOutput\": \"{DailyOutput}\"}}");
            }
        }
        #endregion

        #region 本地云上传
        /// <summary>
        /// 上传当日产量
        /// </summary>
        private void SendDailyOutput()
        {
            //开启云端
            if (init_Cloud)
            {
                try
                {
                    if(!cloudMgr.SendTopic("device/attributes", $"{{ \"DailyOutput\": \"{DailyOutput}\"}}"))
                        Log("云端", $"上传失败", WarningEnum.Low);
                }
                catch (Exception e)
                {
                    Log("云端", $"上传失败:{e.Message}", WarningEnum.Low);
                }
            }
        }
        /// <summary>
        /// 上传正常状态
        /// </summary>
        public void SendStatus()
        {
            //开启云端
            if (init_Cloud)
            {
                //上传报警状态和信息
                string statusStr = "正常";
                switch(StatusMgr.Status)
                {
                    case SystemStsEnum.Manual:
                        statusStr = "人工操作";
                        break;
                    case SystemStsEnum.Standby:
                        statusStr = "正常待机";
                        break;
                    case SystemStsEnum.Initial:
                        statusStr = "初始化";
                        break;
                    case SystemStsEnum.Auto:
                        statusStr = "自动运行";
                        break;
                    case SystemStsEnum.Pause:
                        statusStr = "自动暂停";
                        break;
                    case SystemStsEnum.SetParams:
                        statusStr = "参数设置";
                        break;
                    case SystemStsEnum.Debug:
                        statusStr = "调试";
                        break;
                    case SystemStsEnum.Warning:
                        statusStr = "系统报警";
                        break;
                    case SystemStsEnum.Bootload:
                        statusStr = "Bootload";
                        break;
                    default:
                        statusStr = "未知";
                        break;
                }
                try
                {
                    if(!cloudMgr.SendTopic("device/attributes", $"{{\"status\": \"{statusStr}\",  \"alm\": \"无报警信息\", " +
                    $"\"name\": \"{confMgr.SysConfigParams.CloudThisName}\", \"DailyOutput\": \"{DailyOutput}\"}}"))
                        Log("云端", $"上传失败", WarningEnum.Low);
                }
                catch (Exception e)
                {
                    Log("云端", $"上传失败:{e.Message}", WarningEnum.Low);
                }
            }
        }
        #endregion

        #region 产品服务器
        public bool InitPdtService()
        {
            if (confMgr.SysConfigParams.OpenPdtServer)
            { 
                try
                {
                    if (confMgr.SysConfigParams.IsPdtServer)
                    {
                        myMqttHostServer.StartAsync(confMgr.SysConfigParams.PdtServerPort);
                        Log("产品服务", "产品服务器打开");
                        //自发自测
                        //myMqttClient.MqttClientStart(confMgr.SysConfigParams.PdtServerIP, confMgr.SysConfigParams.PdtServerPort,
                        //    "admin", "123456", confMgr.SysConfigParams.CloudThisName, "pdtinfo");
                        //myMqttClient.RecvRuning += Recv_Process;
                        //Log("产品服务", "产品客户端打开");
                    }
                    else
                    {
                        myMqttClient.MqttClientStart(confMgr.SysConfigParams.PdtServerIP, confMgr.SysConfigParams.PdtServerPort,
                            "admin", "123456", confMgr.SysConfigParams.CloudThisName, "pdtinfo");
                        myMqttClient.RecvRuning += Recv_Process;
                        Log("产品服务", "产品客户端打开");
                    }
                    return true;
                }
                catch (Exception e)
                {
                    Log("产品服务", "产品服务器或客户端打开失败！", WarningEnum.Low);
                    return false;
                }
            }
            return true;
        }

        //产品数据解析
        private int pdtID = -1;
        private List<byte[]> FileDataList = new List<byte[]>();//文件数据
        private byte[] Combine(params byte[][] arrays)
        {
            byte[] rv = new byte[arrays.Sum(a => a.Length)];
            int offset = 0;
            foreach (byte[] array in arrays)
            {
                System.Buffer.BlockCopy(array, 0, rv, offset, array.Length);
                offset += array.Length;
            }
            return rv;
        }
        private void Recv_Process(object sender, RecvEventArgs e)
        {
            Thread t = new Thread(() =>
            {
                if (e.Topic == "TopicToServer")
                {
                    if (pdtID >= 0)
                    {
                        Log("产品服务", "开始接收产品文件");
                        //接收文件
                        JObject json = JObject.Parse(e.Payload);

                        string filename = json.Value<string>("FileName");
                        byte[] datas = Convert.FromBase64String(json.Value<string>("data"));
                        int index = int.Parse(json.Value<string>("index"));
                        int packageNums = int.Parse(json.Value<string>("packageNums"));
                        if (index == 0)
                            FileDataList.Clear();

                        FileDataList.Add(datas);
                        if (index == (packageNums - 1))
                        {
                            byte[] alldatas = Combine(FileDataList.ToArray());
                            //创建文件夹
                            if (!Directory.Exists(ConfMgr.Instance.ProjectDir + $"\\{pdtID}\\"))
                            {
                                Directory.CreateDirectory(ConfMgr.Instance.ProjectDir + $"\\{pdtID}\\");
                            }
                            //2、将byte[]数组保存成文件
                            File.WriteAllBytes(ConfMgr.Instance.ProjectDir + $"\\{pdtID}\\" + filename, alldatas);
                            Log("产品服务", $"保存文件:{ConfMgr.Instance.ProjectDir + $"\\{pdtID}\\" + filename}");
                        }
                    }
                    //else
                    //    Log("产品服务", "中断接收产品文件", WarningEnum.Low);

                }
                else if (e.Topic == "pdtinfo")
                {
                    Log("产品服务", "开始接收产品数据");
                    pdtID = -1;
                    //解析产品数据
                    Product pdt = JsonConvert.DeserializeObject<Product>(e.Payload);
                    pdt.Id = 0;
                    pdt.CompleteCount = 0;
                    pdt.CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code;

                    Models.Attachment attachmentFile = pdt.AttachmentList.FirstOrDefault(m => m.Type == 0);
                    string fileName = attachmentFile.Name;
                    string fileExtend = attachmentFile.ExtendName;
                    string fileOnlyName = fileName.Substring(0, fileName.Length - fileExtend.Length);

                    //判断是否有同样名称数据
                    Product Havepdt = PdtService.GetModelNav(pdt.Code);
                    if(Havepdt != null)
                    {
                        Log("产品服务", $"已存在料号:{pdt.Code}！", WarningEnum.Low);
                        return;
                    }
                    try
                    {
                        bool result = PdtService.InsertNav(pdt);
                    }
                    catch (Exception ex) 
                    {
                        //MyMqttService._recvGet = true;
                        Log("产品服务", $"保存错误:{ex.Message}", WarningEnum.Low);
                        return;
                    }
                    pdt = PdtService.GetModelNav(pdt.Code);


                    attachmentFile = pdt.AttachmentList.FirstOrDefault(m => m.Type == 0);
                    pdtID = pdt.Id;//获取新id

                    if (attachmentFile != null)
                    {
                        attachmentFile.Type = 0;//图纸
                        attachmentFile.NameTimestamp = $"{pdt.Id}\\{fileOnlyName}";
                        attachmentFile.Name = fileName;
                        attachmentFile.ExtendName = fileExtend;
                    }
                    else
                    {
                        pdt.AttachmentList.Add(new Models.Attachment()
                        {
                            TBName = "product",
                            Type = 0,
                            NameTimestamp = $"{pdt.Id}\\{fileOnlyName}",
                            Name = fileName,
                            ExtendName = fileExtend,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    }
                    if (!PdtService.UpdateNav(pdt))
                        throw new Exception("保存文件失败！");
                    //MyMqttService._recvGet = true;
                }

                Log("产品服务", "接收完成");
            });
            t.Start();
        }

        /// <summary>
        /// 发送产品数据
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool SendPdtData(Product model)
        {
            if(model == null)
            {
                MessageBox.Show("无产品数据！","错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }
            Models.Attachment attachmentFile = model.AttachmentList.FirstOrDefault(m => m.Type == 0);
            DialogResult dr = DialogResult.Cancel;
            if ((attachmentFile == null)|| (model.MapPath == null) || (string.IsNullOrEmpty(model.MapPath)))
            {
                dr = MessageBox.Show("无产品图纸数据,是否继续？", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
                if (dr == DialogResult.Cancel)
                {
                    return false;
                }
            }
            string sjson = JsonConvert.SerializeObject(model);
            bool rt = MyMqttService.PublishData("pdtinfo", sjson);
            if (!rt)
            {
                MessageBox.Show("发送失败，网络错误！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }

            //无法做到发送之后等待返回结果，因为多机台客户端无法同步返回
            //DateTime dt = DateTime.Now;
            //while (!MyMqttService._recvGet)
            //{
            //    Thread.Sleep(5);
            //    if ((DateTime.Now - dt).TotalSeconds > 10)
            //    {
            //        MessageBox.Show("发送接收失败，网络错误！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            //        return false;
            //    }
            //}
            Thread.Sleep(2000); //发送数据之后，等待2s发送文件

            if(dr == DialogResult.Cancel)
            {
                rt = MyMqttService.PublishFiles(ConfMgr.Instance.ProjectDir + $"\\{model.Id}\\");
            }
            if(!rt)
            {
                return false;
            }
            return true;
        }
        #endregion

        #region 硬件 

        #region 硬件字段
        private AxisDev axisDev;
        /// <summary>
        /// 运动板卡
        /// </summary>
        public AxisDev AxisDev { get { return axisDev; } }

        private BoardCfgParams boardCfgParams;

        private HomeVelocityParams homeParamsX1;
        public HomeVelocityParams HomeParamsX1 { get { return homeParamsX1; } }

        private HomeVelocityParams homeParamsX2;
        public HomeVelocityParams HomeParamsX2 { get { return homeParamsX2; } }

        private HomeVelocityParams homeParamsY;
        public HomeVelocityParams HomeParamsY { get { return homeParamsY; } }

        private HomeVelocityParams homeParamsZ;
        public HomeVelocityParams HomeParamsZ { get { return homeParamsZ; } }

        private IOCardDev ioCardDev;
        /// <summary>
        /// io控制卡
        /// </summary>
        public IOCardDev IOCardDev { get { return ioCardDev; } }
       
        private LightDev lightDev;
        /// <summary>
        /// 光源控制
        /// </summary>
        public LightDev LightDev { get { return lightDev; } }
        public string LightName { get { return "Light"; } }
        public int LightChCount = 6;//美尚4通道，其他6通道

        private CamDev camDevFront;
        /// <summary>
        /// 前部相机控制
        /// </summary>
        public CamDev CamDevFront { get { return camDevFront; } }

        private CamDev camDevBack;
        /// <summary>
        /// 后部相机控制
        /// </summary>
        public CamDev CamDevBack { get { return camDevBack; } }

        private ValueSensorDev tensionDev;
        /// <summary>
        /// 张力传感器
        /// </summary>
        public ValueSensorDev TensionDev { get { return tensionDev; } }

        private ValueSensorDev thicknessDev;
        /// <summary>
        /// 厚度传感器
        /// </summary>
        public ValueSensorDev ThicknessDev { get { return thicknessDev; } }

        private AxisDev lensMotorDev;
        /// <summary>
        /// 镜头电机
        /// </summary>
        public AxisDev LensMotorDev { get { return lensMotorDev; } }

        private PrintControl printControl;
        /// <summary>
        /// 打印机模块
        /// </summary>
        public PrintControl PrintControl { get { return printControl; } }
        #endregion

        #region 初始化和基本电机IO操作
        private void InitDev()
        {
            axisDev = new AdvantechMotion();
            ioCardDev = new AdvantechIO();
            if(SysUseLight == LightDevNameEnum.CST)
                lightDev = new CSTLight(LightName, LightChCount);
            else 
                lightDev = new RseeLight(SysUseLight, LightName);

            tensionDev = new TensionSensor();
            lensMotorDev = new PmsMotion();
            thicknessDev = new HeightSensorDev();

            camDevFront = new CamDev(SysUseCamFront, confMgr.SysConfigParams.FrontCamName, confMgr.SysConfigParams.FrontCamCfgPath);
            camDevBack = new CamDev(SysUseCamBack, confMgr.SysConfigParams.BackCamName, confMgr.SysConfigParams.BackCamCfgPath);

            defectLib = new DefectLib();
            sizeLib = new SizeLib();

            forLib = new ForLib();
            ifLib = new IFLib();

            boardCfgParams= new BoardCfgParams();
            boardCfgParams.DevEmgLogic = 1;          
        }
        /// <summary>
        /// 初始化硬件
        /// </summary>
        /// <returns></returns>
        private bool InitAllDev()
        { 
            bool ret = false;
            InitDev();

            //打印机模块初始化
            InitLog("打印机模块初始化...");
            try
            {
                printControl = new PrintControl();
                InitLog("初始化打印机模块成功！");
            }
            catch (Exception ex)
            {
                printControl = null;
                InitLog($"初始化打印机模块失败！ {ex.Message}");
            }

            //IO初始化
            InitLog("IO板卡初始化...");           
            if (ioCardDev.InitBoard(MaiMuControl.Device.IOBordType.Advantech) < 0)
            {
                InitLog("IO板卡初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            if(ioCardDev.OpenBoard(confMgr.SysConfigParams.IODevName, confMgr.SysConfigParams.IOCfgPath)<0)
            {
                InitLog("打开IO板卡失败！", "初始化", WarningEnum.High);
                return ret;
            }
            if (ioCardDev.ResetAllDO()<0)
            {
                InitLog("IO Reset失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化IO板卡成功！");

            //电机初始化
            InitLog("运动控制板卡初始化...");
            if(axisDev.InitBoard()<0)
            {
                InitLog("运动控制板卡初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            if (axisDev.OpenBoard(0, confMgr.SysConfigParams.MotionCfgPath) < 0)
            {
                InitLog("打开运动控制板卡失败！", "初始化", WarningEnum.High);
                return ret;
            }
            
            //if (axisDev.LoadCfgFile(0, confMgr.SysConfigParams.MotionCfgPath) < 0)
            //{
            //    InitLog("载入运动控制板卡参数失败2！", "初始化", WarningEnum.High);
            //    return ret;
            //}

            if (axisDev.LoadBoardParams(0, boardCfgParams) < 0)
            {
                InitLog("载入运动控制板卡参数失败1！", "初始化", WarningEnum.High);
                return ret;
            }

            //光源初始化
            InitLog("光源控制器初始化...");
            int com_num = int.Parse(confMgr.SysConfigParams.LightCom.Remove(0, 3));
            if (lightDev.InitDev(com_num, confMgr.SysConfigParams.LightComBaud) < 0)
            {
                InitLog("光源控制器初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化光源控制器成功！");
            //关闭光源
            for (int i = 0; i < LightChCount; i++)
            {
                lightDev.CloseLight(i + 1);
            }

            //张力传感器初始化
            InitLog("张力传感器初始化...");
            if (tensionDev.OpenDevByCom(confMgr.SysConfigParams.TensionCom, confMgr.SysConfigParams.TensionComBaud) < 0)
            {
                InitLog("张力传感器初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化张力传感器成功！");

            //镜头电机初始化
            InitLog("镜头电机初始化...");
            lensMotorDev.InitBoard();
            if (lensMotorDev.OpenBoardByCom(confMgr.SysConfigParams.LensMotorCom, confMgr.SysConfigParams.LensMotorComBaud) < 0)
            {
                InitLog("镜头电机初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化镜头电机成功！");

            //测厚传感器初始化
            InitLog("测厚传感器初始化...");
            if (thicknessDev.OpenDevByTcp(confMgr.SysConfigParams.ThicknessIP, confMgr.SysConfigParams.ThicknessPort) < 0)
            {
                InitLog("测厚传感器初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化测厚传感器成功！");

            //前部相机初始化
            InitLog("前部相机初始化...");
            if(!camDevFront.InitCamera())
            {
                InitLog("前部相机初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            if (!camDevFront.OpenCamera())
            {
                InitLog("前部相机打开失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化前部相机成功！");

            //后部相机初始化
            InitLog("后部相机初始化...");
            if (!camDevBack.InitCamera())
            {
                InitLog("后部相机初始化失败！", "初始化", WarningEnum.High);
                return ret;
            }
            if (!camDevBack.OpenCamera())
            {
                InitLog("后部相机打开失败！", "初始化", WarningEnum.High);
                return ret;
            }
            InitLog("初始化后部相机成功！");
                    
            ret = true;
            return ret;
        }
        /// <summary>
        /// 读取硬件配置
        /// </summary>
        private bool LoadDevConfig()
        {
            homeParamsX1 = axisDev.ReadAxisCfg(confMgr.DevConfigPath, (int)AxisName.Axis0);
            homeParamsX2 = axisDev.ReadAxisCfg(confMgr.DevConfigPath, (int)AxisName.Axis1);
            homeParamsY = axisDev.ReadAxisCfg(confMgr.DevConfigPath, (int)AxisName.Axis2);
            homeParamsZ = axisDev.ReadAxisCfg(confMgr.DevConfigPath, (int)AxisName.Axis3);
                    
            LightParams lightParams = new LightParams(LightName, LightChCount);
            //LightChCount = 6;
            //lightParams.DevName = LightName;
            lightParams.ComName = confMgr.SysConfigParams.LightCom;
            lightParams.Buad = confMgr.SysConfigParams.LightComBaud;
            //lightParams.ChCount = LightChCount;
            lightDev.WriteCfgInfo(confMgr.DevConfigPath, lightParams);

            DevParams devParams = new DevParams("tensionDev", confMgr.SysConfigParams.TensionCom, 
                int.Parse(confMgr.SysConfigParams.TensionCom.Remove(0, 3)), confMgr.SysConfigParams.TensionComBaud);
            tensionDev.WriteDevCfg(confMgr.DevConfigPath, 0, devParams);

            devParams = new DevParams("thicknessDev", confMgr.SysConfigParams.ThicknessIP,
                 confMgr.SysConfigParams.ThicknessPort);
            thicknessDev.WriteDevCfg(confMgr.DevConfigPath, 0, devParams);

            
            //ioCardDev.ReadCfgInfo(confMgr.DevConfigPath, "IO_1");
            if ((homeParamsZ == null) || (homeParamsX1 == null) || (homeParamsX2 == null) || (homeParamsY == null)||
                !homeParamsZ.IsValid() || !homeParamsX1.IsValid() || !homeParamsX2.IsValid() || !homeParamsY.IsValid())
                return false;
            return true;
        }
        /// <summary>
        /// 急停所有电机
        /// </summary>
        private void AxisAllImmediateStop()
        {
            axisDev.ImmediateStop((int)AxisName.Axis0);
            axisDev.ImmediateStop((int)AxisName.Axis1);
            axisDev.ImmediateStop((int)AxisName.Axis2);
            axisDev.ImmediateStop((int)AxisName.Axis3);
        }
        /// <summary>
        /// 减速停止
        /// </summary>
        private void AxisDStop()
        {
            axisDev.DecelStop((int)AxisName.Axis0);
            axisDev.DecelStop((int)AxisName.Axis1);
            axisDev.DecelStop((int)AxisName.Axis2);
            axisDev.DecelStop((int)AxisName.Axis3);
        }
        /// <summary>
        /// 获取脉冲对应的mm距离
        /// </summary>
        /// <param name="axis"></param>
        /// <returns></returns>
        public int GetMMtoPlus(AxisName axis)
        {
            switch (axis)
            {
                case AxisName.Axis0:
                    return HomeParamsX1.MM2PulseNum;
                case AxisName.Axis1:
                    return HomeParamsX2.MM2PulseNum;
                case AxisName.Axis2:
                    return HomeParamsY.MM2PulseNum;
                case AxisName.Axis3:
                    return HomeParamsZ.MM2PulseNum;
                default: return 1;
            }
        }

        /// <summary>
        /// I/O指令输出
        /// </summary>
        /// <param name="processParam"></param>
        /// <param name="isStrobe">频闪</param>
        /// <param name="recover">输出sleep(recoverWaitTime)下，后恢复原信号</param>
        /// <param name="recoverWaitTime">sleep 后反转</param>
        public bool io_output(string tagName, JObject processParam, bool isStrobe = false, bool recover = false, int recoverWaitTime = 100)
        {
            bool result = false;
            string[] OUT_OP_SHOW = processParam.Value<JArray>("OUT_OP_SHOW").ToObject<List<string>>().ToArray();
            OUT_OP_SHOW = IODataFormatBinaryStr(OUT_OP_SHOW, true);
            for (int i = 0; i < OUT_OP_SHOW.Length; i++)
            {
                for (int j = 0; j < OUT_OP_SHOW[i].Length; j++)
                {
                    int jj = OUT_OP_SHOW[i].Length - j - 1;
                    if (OUT_OP_SHOW[i][jj] == 'L' || OUT_OP_SHOW[i][jj] == 'H')
                    {
                        if (recover)
                        {
                            if (recoverWaitTime > 0)
                            {                               
                                ioCardDev.WriteBitState(i, j, OUT_OP_SHOW[i][jj] == 'H');
                                Thread.Sleep(recoverWaitTime);
                            }
                            ioCardDev.WriteBitState(i, j, OUT_OP_SHOW[i][jj] == 'L');
                        }
                        else
                        {
                            ioCardDev.WriteBitState(i, j, OUT_OP_SHOW[i][jj] == 'H');
                        }
                        result = true;
                    }
                }
            }

            return result;
        }
        
        /// <summary>
        /// 多轴判断到位
        /// </summary>
        /// <param name="axisList"></param>
        /// <returns></returns>
        public bool WaitAxisDone(List<int> axisList)
        {
            foreach (int i in axisList)
            {
                if (axisDev.CheckDone(i, 30) != 0)
                {   
                    return false;
                }
            }
            return true;
        }
        public bool WaitAllAxisDone()
        {
            for (int i = 0; i < 4; i++)
            {
                if (axisDev.CheckDone(i, 30) != 0)
                {
                    return false;
                }
            }
            return true;
        }

        public double GetAxisPosValueMM(int axisNo)
        {
            double pos = axisDev.GetFeedbackPos(axisNo);
            return pos / (double)GetMMtoPlus((AxisName)axisNo);
        }
        #endregion
        #endregion

        #region 公开字段
        private bool _isInit;
        /// <summary>
        /// 是否初始化完成
        /// </summary>
        public bool IsInit {  get { return _isInit; } }
        private bool _isRuning;
        /// <summary>
        /// 设备正在运行
        /// </summary>
        public bool IsRuning { get { return _isRuning; } }

        private bool _isAuto;
        /// <summary>
        /// 设备正在自动化流程中
        /// </summary>
        public bool IsAuto { get { return _isAuto; } }
        #endregion      

        #region 用户+登入+管理
        /// <summary>
        /// 登入
        /// </summary>
        /// <returns></returns>
        public bool LoginSystem()
        {
            return userMgr.UserLoginDialog();
        }
        /// <summary>
        /// 用户权限
        /// </summary>
        public void UserPermissiomMgr()
        {
            userMgr.RightManageDialog();
        }
        /// <summary>
        /// 用户管理
        /// </summary>
        public void UserListMgr()
        {
            userMgr.UserManagerDialog();
        }
        #endregion

        #region 系统初始化&&运行
        /// <summary>
        /// 系统初始化
        /// </summary>
        /// <returns></returns>
        public bool Initial()
        {
            try
            {
                bool ret = false;
                string err = "";
                InitLog("系统开始初始化...");
                //Thread.Sleep(200);

                // 加载系统配置
                InitLog("加载系统参数...");
                ret = confMgr.LoadSystemConfig();
  
                if (!ret)
                {
                    throw new Exception("系统参数加载失败...");                   
                }
                InitLog("系统参数加载完成！");
                //根据llog路径，开始记录日志
                statusMgr.StartLog(confMgr.SysConfigParams.LogPath);
                statusMgr.GotoInitial();
                SendStatus();
                //Thread.Sleep(200);

                // 硬件初始化
                if (!InitAllDev())
                {
                    throw new Exception("硬件初始化失败...");
                }
                InitLog("硬件初始化完成！");

                // 加载硬件配置
                InitLog("加载硬件驱动参数...");
                if (!LoadDevConfig())
                {
                    throw new Exception("加载硬件驱动参数失败...");
                }
                InitLog("加载硬件驱动参数完成！");
                //Thread.Sleep(200);

                // 处理运行
                InitLog("AI算法核心初始化...");
                
                if (!defectLib.start())
                    throw new Exception("外观检测核心初始化失败...");
                if (!sizeLib.start(confMgr.SysConfigParams.ImageProcessPath))
                    throw new Exception("尺寸检测核心初始化失败...");
                InitLog("AI算法核心初始化完成！");

                InitLog("镜头电机回原...");
                //镜头电机回原
                lensMotorDev.BackHome(0, new HomeVelocityParams());
                lensMotorDev.CheckHomeDone(0, 3000);
                //移动到 4.5X
                //lensMotorDev.MoveAbsPulse(0, new VelocityCurveParams(), (int)SmallAxCmdPos.倍率4_5X);
                //lensMotorDev.CheckDone(0, 5000);
                InitLog("镜头电机回原完成！");

                //移动Axis前等待厚度传感器收回
                InitLog("检测厚度传感器安全值...");
                double TempVal = thicknessDev.GetValue();
                if (TempVal < Math.Abs(confMgr.SysConfigParams.ThicknessSafeValue))
                    throw new Exception("厚度传感器不在安全位置！");


                //多轴回原
                if (confMgr.SysConfigParams.OpenAutoGoHome)
                {
                    if ((homeParamsZ != null) && (homeParamsX1 != null) && (homeParamsX2 != null) && (homeParamsY != null))
                    {
                        axisDev.ResetAxisState((int)AxisName.Axis0);
                        axisDev.ResetAxisState((int)AxisName.Axis1);
                        axisDev.ResetAxisState((int)AxisName.Axis2);
                        axisDev.ResetAxisState((int)AxisName.Axis3);
                        InitLog("Z轴开始回原点...");
                        axisDev.BackHome((int)AxisName.Axis3, homeParamsZ);
                        InitLog("X1轴开始回原点...");
                        axisDev.BackHome((int)AxisName.Axis0, homeParamsX1);
                        InitLog("X2轴开始回原点...");
                        axisDev.BackHome((int)AxisName.Axis1, homeParamsX2);
                        InitLog("Y轴开始回原点...");
                        //axisDev.BackHome((int)AxisName.Axis1, homeParamsY);
                        //y轴使用io回原
                        if (!AxisYGoHome())
                            throw new Exception("Y轴回原报警！");
                    }
                    Thread.Sleep(1000);
                    //判断轴是否回原成功
                    if (!AxisYGoHomeDone(60))
                    {
                        AxisAllImmediateStop();
                        throw new Exception("Y轴回原失败！");
                    }

                    if (axisDev.CheckHomeDone((int)AxisName.Axis0, 60) != 0)
                    {
                        AxisAllImmediateStop();
                        throw new Exception("X1轴回原失败！");
                    }
                    if (axisDev.CheckHomeDone((int)AxisName.Axis1, 60) != 0)
                    {
                        AxisAllImmediateStop();
                        throw new Exception("X2轴回原失败！");
                    }
                    if (axisDev.CheckHomeDone((int)AxisName.Axis3, 60) != 0)
                    {
                        AxisAllImmediateStop();
                        throw new Exception("Z轴回原失败！");
                    }
                    InitLog("所有轴回原成功！");

                    //清空y轴发送命令和反馈位置
                    axisDev.SetCommandPos((int)AxisName.Axis2, 0);
                    axisDev.SetFeedbackPos((int)AxisName.Axis2, 0);

                    //X轴标定启用
                    if(confMgr.SysConfigParams.OpenAxisXCalibration)
                    {
                        OpenAxisXCal();
                    }
                }

                LedReady();
                if (confMgr.SysConfigParams.OpenAutoGoHome)
                {
                    InitLog("移动到上料...");
                    //Thread.Sleep(500);
                    if (!GotoLoadPos())
                    {
                        throw new Exception("移动到上料失败！");
                    }
                }


                //初始化成功
                _isInit = true;
                statusMgr.GotoNormalStandby();
                SendStatus();

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

                Run();

                return ret;
            }
            catch (Exception ex)
            {
                InitLog(ex.Message, "初始化", WarningEnum.High);
                InitLog("系统初始化失败！" , "初始化", WarningEnum.High);
                //statusMgr.GotoWarning(MaiMuControl.Device.WarningEnum.High, "初始化", ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 初始化图像处理报警
        /// </summary>
        /// <returns></returns>
        public bool InitDefectEvent()
        { 
            defectLib.WarningEvent = (warning, msg) =>
            {
                Log("缺陷处理", msg, warning);
            };
            sizeLib.WarningEvent = (warning, msg) =>
            {
                Log("尺寸检测", msg, warning);
            };
            return true;
        }

        /// <summary>
        /// 开启修复台web服务器
        /// </summary>
        /// <returns></returns>
        public bool InitWebServer()
        {
            //InitLog("开启数据服务器...");
            webService.Defect_Compress_SavePath = confMgr.SysConfigParams.DefectRepairImag.SavePath;
            webService.SizeBmp_Zoom_Image_SavePath = confMgr.SysConfigParams.SizeRepairImag.SavePath;
            webService.LogEvent = (warning, msg) =>
            {
                Log("HTTP服务", msg, warning);
                //OnMainRuning(new MainEventArgs("HTTP服务", msg, warning));
                if(!confMgr.SysConfigParams.OpenHttpLog)
                    webService.LogEvent = null;
            };
            webService.start(confMgr.SysConfigParams.HttpServerIP, confMgr.SysConfigParams.HttpServerPort);
            //InitLog("开启数据服务器完成！");
            Thread.Sleep(200);
            return true;
        }

        public bool InitCloudConnect()
        {
            if (confMgr.SysConfigParams.OpenCloud)
            {
                if (cloudMgr.ConnectCloud(confMgr.SysConfigParams.CloudServerIP, confMgr.SysConfigParams.CloudServerPort,
                    confMgr.SysConfigParams.CloudUser, confMgr.SysConfigParams.CloudPassword))
                {
                    init_Cloud = true;
                    Log("云端数据", "开启云端连接");
                    return true;
                }
                Log("云端数据", "云端连接失败！", WarningEnum.Low);
                return false;
            }
            return true;
        }
        /// <summary>
        /// 运行主线程
        /// </summary>
        private void Run()
        {
            _mainThread = new Thread(() =>
            {
                MainThreadFunction();
            });
            _mainThread.IsBackground = true;
            _mainThread.Start();
        }
        #endregion

        #region 系统关闭
        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            _isInit = false;
            _isRuning = false;
            if (null != _cts)
            {
                _cts.Cancel();
            }
            if (null != _mainThread)
            {
                _mainThread.Join(1000);
            }

            webService.stop();

            AxisDStop();
            axisDev.SetServo((int)AxisName.Axis0, 0);
            axisDev.SetServo((int)AxisName.Axis1, 0);
            axisDev.SetServo((int)AxisName.Axis2, 0);
            axisDev.SetServo((int)AxisName.Axis3, 0);
            axisDev.CloseBoard();

            //关闭相机
            camDevFront.CloseCamera();
            camDevBack.CloseCamera();
            
            //关闭光源
            for (int i = 0; i < LightChCount; i++)
            {
                lightDev.CloseLight(i + 1);
            }
            //lightDev.CloseLight((int)LightChannelEnum.CH1);
            //lightDev.CloseLight((int)LightChannelEnum.CH2);
            //lightDev.CloseLight((int)LightChannelEnum.CH3);
            //lightDev.CloseLight((int)LightChannelEnum.CH4);
            //lightDev.CloseLight((int)LightChannelEnum.CH5);
            //lightDev.CloseLight((int)LightChannelEnum.CH6);

            lightDev.CloseDev();

            //关闭传感器
            thicknessDev.CloseDev();
            tensionDev.CloseDev();
            lensMotorDev.CloseBoard();

            //关闭io
            ioCardDev.ResetAllDO();

            ioCardDev.CloseBoard();

        }
        #endregion

        #region 产品管理
        
        public string SelectProduct()
        {
            InputFrm frm = new InputFrm(productCodeList, "请选择产品料号:");
            if (frm.ShowDialog() != DialogResult.OK && string.IsNullOrWhiteSpace(frm.inputData))
                return "";
            //显示料号
            //this.txtProductCode.Text = frm.inputData;
            var model = PdtService.GetModelNav(frm.inputData);
            if (model != null && model.StepInfo.ProcessList.Count > 0)
            {
                //名称料号显示一个就可以
                return  model.Code;
            }
            return "";
        }
        /// <summary>
        /// 拷贝产品
        /// </summary>
        /// <param name="list"></param>
        /// <param name="liIndex"></param>
        /// <returns></returns>
        public bool ProductCopy(List<Product> list, int liIndex)
        {
            Product newProduct = new Product()
            {
                Code = list[liIndex].Code + "_clone",
                Name = $"{list[liIndex].Name} (克隆)",
                Spec = list[liIndex].Spec,
                ClassesId = list[liIndex].ClassesId,
                ClassesInfo = list[liIndex].ClassesInfo,
                HoleCount = list[liIndex].HoleCount,
                DefectModelFile = list[liIndex].DefectModelFile,
                AttachmentList = new List<Attachment>(),
                BatchId = list[liIndex].BatchId,
                TargetCount = list[liIndex].TargetCount,
                CompleteCount = list[liIndex].CompleteCount,
                BatchHistoryList = new List<BatchHistory>(),
                QualifiedCriterionList = new List<QualifiedCriterion>(),
                Note = list[liIndex].Note,
                TensionBaseValue = list[liIndex].TensionBaseValue,
                TensionUpFloatValue = list[liIndex].TensionUpFloatValue,
                TensionDownFloatValue = list[liIndex].TensionDownFloatValue,
                HeightBaseValue = list[liIndex].HeightBaseValue,
                HeightUpFloatValue = list[liIndex].HeightUpFloatValue,
                HeightDownFloatValue = list[liIndex].HeightDownFloatValue,
                LineWidthBaseValue = list[liIndex].LineWidthBaseValue,
                LineWidthUpFloatValue = list[liIndex].LineWidthUpFloatValue,
                LineWidthDownFloatValue = list[liIndex].LineWidthDownFloatValue,
                PTBaseValue = list[liIndex].PTBaseValue,
                PTUpFloatValue = list[liIndex].PTUpFloatValue,
                PTDownFloatValue = list[liIndex].PTDownFloatValue,
                HeightBaseDec = list[liIndex].HeightBaseDec,

                StepId = list[liIndex].StepId,
                StepInfo = list[liIndex].StepInfo,
                ProductProcessList = new List<ProductProcess>(),
                ReviseStepId = list[liIndex].ReviseStepId,
                ReviseStepInfo = list[liIndex].ReviseStepInfo,
                ProductReviseProcessList = new List<ProductReviseProcess>(),
                AssistStepId = list[liIndex].AssistStepId,
                AssistStepInfo = list[liIndex].AssistStepInfo,
                ProductAssistProcessList = new List<ProductAssistProcess>(),

                //OrderList = new List<Order>(),

                ModifyUserCode = userMgr.LoginUser.Code,
                CreateUserCode = userMgr.LoginUser.Code
            };
            foreach (var item in list[liIndex].AttachmentList)
            {
                newProduct.AttachmentList.Add(new Attachment()
                {
                    TBName = item.TBName,
                    Type = item.Type,
                    Pid = item.Pid,
                    Name = item.Name,
                    NameTimestamp = item.NameTimestamp,
                    ExtendName = item.ExtendName,
                    ModifyUserCode = userMgr.LoginUser.Code,
                    CreateUserCode = userMgr.LoginUser.Code
                });
            }
            foreach (var item in list[liIndex].BatchHistoryList)
            {
                newProduct.BatchHistoryList.Add(new BatchHistory()
                {
                    Pid = item.Pid,
                    BatchId = item.BatchId,
                    TargetCount = item.TargetCount,
                    CompleteCount = item.CompleteCount,

                    ModifyUserCode = userMgr.LoginUser.Code,
                    CreateUserCode = userMgr.LoginUser.Code
                });
            }
            foreach (var item in list[liIndex].QualifiedCriterionList)
            {
                newProduct.QualifiedCriterionList.Add(new QualifiedCriterion()
                {
                    Pid = item.Pid,
                    DefectCode = item.DefectCode,
                    Size = item.Size,
                    MaxDefectCount = item.MaxDefectCount,

                    ModifyUserCode = userMgr.LoginUser.Code,
                    CreateUserCode = userMgr.LoginUser.Code
                });
            }
            foreach (var item in list[liIndex].ProductProcessList)
            {
                newProduct.ProductProcessList.Add(new ProductProcess()
                {
                    Pid = item.Pid,
                    ProcessCode = item.ProcessCode,
                    ProcessParams = item.ProcessParams,

                    ModifyUserCode = userMgr.LoginUser.Code,
                    CreateUserCode = userMgr.LoginUser.Code
                });
            }
            foreach (var item in list[liIndex].ProductReviseProcessList)
            {
                newProduct.ProductReviseProcessList.Add(new ProductReviseProcess()
                {
                    Pid = item.Pid,
                    ProcessCode = item.ProcessCode,
                    ProcessParams = item.ProcessParams,

                    ModifyUserCode = userMgr.LoginUser.Code,
                    CreateUserCode = userMgr.LoginUser.Code
                });
            }
            foreach (var item in list[liIndex].ProductAssistProcessList)
            {
                newProduct.ProductAssistProcessList.Add(new ProductAssistProcess()
                {
                    Pid = item.Pid,
                    ProcessCode = item.ProcessCode,
                    ProcessParams = item.ProcessParams,

                    ModifyUserCode = userMgr.LoginUser.Code,
                    CreateUserCode = userMgr.LoginUser.Code
                });
            }
            /*
            foreach (var item in list[liIndex].OrderList)
            {
                newProduct.OrderList.Add(new Order()
                {
                    ProductId = item.ProductId,
                    ProductInfo = item.ProductInfo,
                    SN = item.SN,

                    ModifyUserCode = Config.loginUser.Code,
                    CreateUserCode = Config.loginUser.Code
                });
            }*/
            bool result = PdtService.InsertNav(newProduct);

            return result;
        }
        /// <summary>
        /// 加载产品列表
        /// </summary>
        public void LoadProductCodeList()
        {
            try
            {
                productCodeList = PdtService.GetList().Select(m => m.Code).ToList();
                productIdList = PdtService.GetList().Select(m => m.Id).ToList();
                //string[] array = ReadSNText();
                //if (array != null && array.Length > 0)
                //{    
                //    for (int i = 0; i < array.Length; i++)
                //        productSNList.Add(array[i]);
                //}
            }
            catch (Exception ex)
            {
                //throw new Exception("加载产品料号失败:" + ex.Message);
                OnMainRuning(new MainEventArgs("启动", "加载产品料号失败:" + ex.Message, WarningEnum.High));
                statusMgr.GotoWarning(WarningEnum.High, "启动", "加载产品料号失败:" + ex.Message);
                SendStatus();
            }
        }
        /// <summary>
        /// 记录使用的sn
        /// </summary>
        /// <param name="str"></param>
        public void Remind(string str)
        {
            string workPath = Directory.GetCurrentDirectory();
            string textPath = Path.Combine(workPath, "TextRemind.txt");
            try
            {
                if (productSNList.Count == 0 || !productSNList.Contains(str))
                {
                    if (productSNList.Count > 20)
                        productSNList.RemoveAt(0);
                    productSNList.Add(str);
                    //File.AppendAllLines(textPath, new string[] { str }); 
                }
                if(productSNList.Count > 0)
                {
                    File.WriteAllLines(textPath, productSNList);
                }
            }
            catch
            {
            }
        }
        /// <summary>
        /// 读取近期sn
        /// </summary>
        /// <returns></returns>
        private string[] ReadSNText()
        {
            string workPath =  Directory.GetCurrentDirectory();
            string textPath = Path.Combine(workPath, "TextRemind.txt");
            try
            {
                if (!File.Exists(textPath))
                    return null;

                return File.ReadAllLines(textPath);
            }
            catch
            {
                return null;
            }
        }
        #endregion

        #region 流程步骤
        private static void InitDevDic()
        {
            //旧版流程
            //dicDevType.Add("CodeScanner", "扫码枪");//固定为必有开始
            if (!dicDevType.ContainsKey("IOCard")) dicDevType.Add("IOCard", "I/O控制");
            //if (!dicDevType.ContainsKey("Tension")) dicDevType.Add("Tension", "张力测量");
            if (!dicDevType.ContainsKey("Height")) dicDevType.Add("Height", "厚度测量");
            if (!dicDevType.ContainsKey("Axis")) dicDevType.Add("Axis", "滑台电机");
            if (!dicDevType.ContainsKey("AxisTag")) dicDevType.Add("AxisTag", "滑台&测量");
            if (!dicDevType.ContainsKey("Light")) dicDevType.Add("Light", "光源");
            if (!dicDevType.ContainsKey("Scanner_CC")) dicDevType.Add("Scanner_CC", "前部相机拍照");
            if (!dicDevType.ContainsKey("Scanner_GENTL")) dicDevType.Add("Scanner_GENTL", "后部相机拍照");
            if (!dicDevType.ContainsKey("SmallAxis")) dicDevType.Add("SmallAxis", "镜头电机");
            if (!dicDevType.ContainsKey("Defect")) dicDevType.Add("Defect", "缺陷检测");
            if (!dicDevType.ContainsKey("Size")) dicDevType.Add("Size", "尺寸测量");
            if (!dicDevType.ContainsKey("For")) dicDevType.Add("For", "For循环");
            if (!dicDevType.ContainsKey("If")) dicDevType.Add("If", "If条件");

            //新版流程
            if (!ProcessType.ContainsKey("Tension")) ProcessType.Add("Tension", "张力测量");
            if (!ProcessType.ContainsKey("Height")) ProcessType.Add("Height", "厚度测量");
            if (!ProcessType.ContainsKey("LensMotor")) ProcessType.Add("LensMotor", "镜头变焦");
            if (!ProcessType.ContainsKey("Light")) ProcessType.Add("Light", "光源设置");
            if (!ProcessType.ContainsKey("Mark")) ProcessType.Add("Mark", "Mark检测");
            if (!ProcessType.ContainsKey("PointTest")) ProcessType.Add("PointTest", "尺寸检测");
            if (!ProcessType.ContainsKey("SizeAndDefect")) ProcessType.Add("SizeAndDefect", "外观检测");
            if (!ProcessType.ContainsKey("For")) ProcessType.Add("For", "测试循环");
        }
        #endregion

        #region 操作

        #region webLogg
        public void CheckWebLog()
        {
            if (!confMgr.SysConfigParams.OpenHttpLog)
                webService.LogEvent = null;
            else
            {
                webService.LogEvent = (warning, msg) =>
                {
                    Log("HTTP服务", msg, warning);
                    //OnMainRuning(new MainEventArgs("HTTP服务", msg, warning));

                };
            }
        }
        #endregion

        #region 上料移动
        /// <summary>
        /// 关闭光源移动到上料位置
        /// </summary>
        /// <returns></returns>
        public bool GotoLoadPos()
        {
            bool ret = true;
            //关闭光源
            for (int i = 0; i < LightChCount; i++)
            {
                lightDev.CloseLight(i + 1);
            }

            VelocityCurveParams vel_z = new VelocityCurveParams(DefaultSpeed / 2, DefaultSpeed / 2, 0, DefaultSpeed / 2, 1, GetMMtoPlus(AxisName.Axis3));
            axisDev.MoveAbsValue((int)AxisName.Axis3, vel_z, confMgr.LoadPoint_Z);
            if (axisDev.CheckDone((int)AxisName.Axis3, 30) != 0)
                return false;

            VelocityCurveParams vel_x1 = new VelocityCurveParams(DefaultSpeed, DefaultSpeed, 0, DefaultSpeed, 1, GetMMtoPlus(AxisName.Axis0));
            axisDev.MoveAbsValue((int)AxisName.Axis0, vel_x1, confMgr.LoadPoint_X1);
            VelocityCurveParams vel_x2 = new VelocityCurveParams(DefaultSpeed, DefaultSpeed, 0, DefaultSpeed, 1, GetMMtoPlus(AxisName.Axis1));
            axisDev.MoveAbsValue((int)AxisName.Axis1, vel_x2, confMgr.LoadPoint_X2);

            VelocityCurveParams vel_y = new VelocityCurveParams(DefaultSpeed, DefaultSpeed, 0, DefaultSpeed, 1, GetMMtoPlus(AxisName.Axis2));
            axisDev.MoveAbsValue((int)AxisName.Axis2, vel_y, confMgr.LoadPoint_Y);

            if (axisDev.CheckDone((int)AxisName.Axis0, 30) != 0)
                return false;
            if (axisDev.CheckDone((int)AxisName.Axis1, 30) != 0)
                return false;
            if (axisDev.CheckDone((int)AxisName.Axis2, 30) != 0)
                return false;
            return ret;
        }
        #endregion

        #region 急停
        /// <summary>
        /// 急停设备
        /// </summary>
        public void EmergencyStop()
        {
            Log("设备", "紧急停止", WarningEnum.High);
            _isAuto = false;
            AxisAllImmediateStop();
        }
        #endregion

        #region IO气缸
        private int GetIOPortIndex(int DIDOEnum)
        {
            return DIDOEnum / 8;
        }
        private int GetIOBitIndex(int DIDOEnum)
        {
            return DIDOEnum % 8;
        }
        /// <summary>
        /// 开关照明灯
        /// </summary>
        /// <param name="open"></param>
        public void OpenFloodlight(bool open)
        {
            ////记录日产量
            //if (confMgr.SetDailyOutputAdd(out DailyOutput))
            //{
            //    SendDailyOutput();
            //}

            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.日光灯), GetIOBitIndex((int)DOName.日光灯), open);
        }
        /// <summary>
        /// 产品夹紧气缸控制
        /// </summary>
        /// <param name="ack"></param>
        /// <returns></returns>
        public bool RunQG(bool ack)
        {
            bool ret;
            ret = ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.加紧气缸), GetIOBitIndex((int)DOName.加紧气缸), ack);
            Thread.Sleep(500);
            //ret = ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.加紧气缸), GetIOBitIndex((int)DOName.加紧气缸), ack);
            return ret;
        }
        /// <summary>
        /// 获取加紧气缸IO状态
        /// </summary>
        /// <returns></returns>
        public bool QGSts()
        {
            bool sts;
            ioCardDev.GetDOBitState(GetIOPortIndex((int)DOName.加紧气缸), GetIOBitIndex((int)DOName.加紧气缸), out sts);
            return sts;
        }

        /// <summary>
        /// 测厚气缸控制
        /// </summary>
        /// <param name="ack"></param>
        /// <returns></returns>
        public bool RunThickness(bool ack)
        {
            bool ret;
            ret = ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), ack);
            Thread.Sleep(500);
            return ret;
        }
        /// <summary>
        /// 获取测厚气缸IO状态
        /// </summary>
        /// <returns></returns>
        public bool ThicknessSts() 
        {
            bool sts;
            ioCardDev.GetDOBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), out sts);
            return sts;
        }

        #endregion

        #region 测厚安全
        /// <summary>
        /// 判断测厚气缸是否在安全位置
        /// </summary>
        /// <returns></returns>
        public bool ThicknessIsSafe()
        {
            //RunThickness(false);
            bool sts;
            ioCardDev.GetDOBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), out sts);
            if(sts)
                return false;
            if (thicknessDev.GetValue() < Math.Abs(confMgr.SysConfigParams.ThicknessSafeValue))
                return false;
            return true;
        }
        #endregion

        #region 三色灯
        /// <summary>
        /// 三色灯初始化
        /// </summary>
        public void LedReady()
        {
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
        }
        /// <summary>
        /// 运行状态三色灯
        /// </summary>
        public void LedRun()
        {
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), true);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), true);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
        }
        /// <summary>
        /// 暂停状态三色灯
        /// </summary>
        public void LedPause()
        {
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), true);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
        }
        //控制黄灯闪烁
        private bool Blink;
        private int BlinkCnt = 0;
        //控制蜂鸣间隔
        private int BuzzCnt = 0;
        /// <summary>
        /// 回原状态三色灯
        /// </summary>
        /// <param name="val"></param>
        public void LedRset(bool val)
        {
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
            //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), val);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);

            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), val);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
            Blink = val;
            BlinkCnt = 0;
        }
        #endregion

        #region 轴回原
        /// <summary>
        /// 启用X轴标定
        /// </summary>
        private void OpenAxisXCal()
        {
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.X1回原), GetIOBitIndex((int)DOName.X1回原), true);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.X2回原), GetIOBitIndex((int)DOName.X2回原), true);
            Thread.Sleep(300);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.X1回原), GetIOBitIndex((int)DOName.X1回原), false);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.X2回原), GetIOBitIndex((int)DOName.X2回原), false);
        }
        /// <summary>
        /// Y轴回原，使用信号回原，因为驱动器中有标定参数需要驱动器控制回原才起效
        /// </summary>
        /// <returns></returns>
        private bool AxisYGoHome()
        {
            //加入读取急停信号
            AxisSignalState axisSignalState =  axisDev.GetAxisState((int)AxisName.Axis2);
            if(axisSignalState.EMG !=  GeneralElectricalLevelMode.High)
            {
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.Y轴回原点), GetIOBitIndex((int)DOName.Y轴回原点), true);
                return true;
            }
            return false;
        }
        /// <summary>
        /// 判断y轴是否回原
        /// </summary>
        /// <param name="timeout"></param>
        /// <returns></returns>
        private bool AxisYGoHomeDone(double timeout)
        {
            System.Diagnostics.Stopwatch strtime = new System.Diagnostics.Stopwatch();
            strtime.Start();
            do
            {
                //加入读取急停信号
                AxisSignalState axisSignalState = axisDev.GetAxisState((int)AxisName.Axis2);
                if (axisSignalState.EMG == GeneralElectricalLevelMode.High)
                {
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.Y轴回原点), GetIOBitIndex((int)DOName.Y轴回原点), false);
                    return false;
                }
                    //判断是否正常停止
                    bool sts;
                ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.Y轴回原点完成), GetIOBitIndex((int)DIName.Y轴回原点完成), out sts);
                if (sts)
                    break;

                //检查是否超时
                strtime.Stop();
                if (strtime.ElapsedMilliseconds / 1000.0 > timeout)
                {
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.Y轴回原点), GetIOBitIndex((int)DOName.Y轴回原点), false);
                    return false;
                }
                strtime.Start();

                //延时
                System.Threading.Thread.Sleep(20);
            } while (true);
            Thread.Sleep(500);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.Y轴回原点), GetIOBitIndex((int)DOName.Y轴回原点), false);
            return true;
        }
        #endregion

        #region 上料位
        public bool GotoReadyPosAndIO()
        {
            Log("复位", "系统复位");
            _isAuto = false;
            CurrProcessIndex = -1;
            CurrPoinntCount = 0;
            CurrStepResult = 0;

            if(!RunThickness(false))
            {
                Log("复位", "测厚气缸复位失败", WarningEnum.High);
                return false;
            }

            bool ret = GotoLoadPos();
            if (!ret)
            {
                Log("复位", "系统电机复位失败", WarningEnum.High);
                return false;
            }

            if (!RunQG(false))
            {
                Log("复位", "加紧气缸复位失败", WarningEnum.High);
                return false;
            }

            LedReady();

            statusMgr.GotoNormalStandby();
            SendStatus();
            Log("复位", "复位完成");
            return ret;
        }
        /// <summary>
        /// 确认当前位置为上料位置
        /// </summary>
        /// <returns></returns>
        private bool CheckPosIsLoadPos()
        {
            bool ret = false;
            double x1 = GetAxisPosValueMM((int)AxisName.Axis0);
            double x2 = GetAxisPosValueMM((int)AxisName.Axis1);
            double y = GetAxisPosValueMM((int)AxisName.Axis2);
            double z = GetAxisPosValueMM((int)AxisName.Axis3);
            ret = Math.Abs(x1 - confMgr.LoadPoint_X1) < 1;
            ret = ret & Math.Abs(x2 - confMgr.LoadPoint_X2) < 1;
            ret = ret & Math.Abs(y - confMgr.LoadPoint_Y) < 1;
            ret = ret & Math.Abs(z - confMgr.LoadPoint_Z) < 1;
            return ret;
        }
        #endregion

        #region 张力操作
        /// <summary>
        /// 读取张力数据
        /// </summary>
        /// <returns></returns>
        public double TensionGetValue(out TensionResult tensionResult)
        {
            tensionResult = new TensionResult(0, 0, 0, Color.Empty, Color.Empty, Color.Empty);
            if (confMgr.SysConfigParams.DisableTensor)
            {
                Log("张力读取", "张力设备禁用，忽略此步骤!");
                return -1;
            }
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.触发张力按钮灯), GetIOBitIndex((int)DOName.触发张力按钮灯), true);

            double tensionValue = 0;
            for (int i = 0; i < 5; i++)
            {
                tensionValue = tensionDev.GetValue() + confMgr.SysConfigParams.Tension_Offset;//加入张力偏差
                tensionValue = Math.Round(tensionValue, 2);//保留2位小数
                if (tensionValue >= 0)
                    break;
            }
            if (tensionValue < 0)
            {
                Log("张力读取", "张力读取失败，忽略此次测试!");
                return -1;
            }

            Log("张力读取", $"张力值:{tensionValue}");
            Thread.Sleep(500);
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.触发张力按钮灯), GetIOBitIndex((int)DOName.触发张力按钮灯), false);
            lstTension.Add(tensionValue);
            if (lstTension.Count == 1)
                order.Tension1 = tensionValue;
            else if (lstTension.Count == 2)
                order.Tension2 = tensionValue;
            else if (lstTension.Count == 3)
                order.Tension3 = tensionValue;
            else if (lstTension.Count == 4)
                order.Tension4 = tensionValue;
            else if (lstTension.Count == 5)
                order.Tension5 = tensionValue;

            //TensionResult tensionResult;
            if (CurrProductModel != null)
                updateTensionValue(CurrProductModel.TensionBaseValue + CurrProductModel.TensionUpFloatValue, CurrProductModel.TensionBaseValue - CurrProductModel.TensionDownFloatValue, out tensionResult);

            return tensionValue;
        }
        /// <summary>
        /// 新流程联动读取张力
        /// </summary>
        /// <returns></returns>
        public double TensionGetValueNewStep()
        {
            double tensionValue = 0;
            for (int cnt = 0; cnt < 2; cnt++)
            {
                for (int i = 0; i < 10; i++)
                {
                    tensionValue = tensionDev.GetValue() + confMgr.SysConfigParams.Tension_Offset;//加入张力偏差
                    tensionValue = Math.Round(tensionValue, 2);//保留2位小数
                    if (tensionValue >= 0)
                        break;
                    Thread.Sleep(50);
                }
                //成功读取跳出循环
                if (tensionValue >= 0)
                    break;
                else
                {
                    //重连
                    tensionDev.CloseDev();
                    Thread.Sleep(100);
                    if (tensionDev.OpenDevByCom(confMgr.SysConfigParams.TensionCom, confMgr.SysConfigParams.TensionComBaud) < 0)
                    {
                        Log("张力传感器重连失败！", "重连", WarningEnum.High);
                        return -10;
                    }
                }
            }
            if (tensionValue < 0)
            {
                return -1;
            }

            return tensionValue;
        }
        public class TensionResult
        {
            public double value = 0;
            public double valueMax = 0;
            public double valueMin = 0;
            public Color color = Color.Empty;
            public Color colorMax = Color.Empty;
            public Color colorMin = Color.Empty;
            public TensionResult(double val, double valMax, double valMin, Color clr, Color clrMax, Color clrMin) { 
                value = val; valueMax = valMax; valueMin = valMin; color = clr; colorMax = clrMax; colorMin = clrMin;
            }
        }
        private void updateTensionValue(double upperLimit, double lowerLimit, out TensionResult tensionResult)
        {
            int count = lstTension.Count();
            tensionResult = new TensionResult(0,0,0, Color.Empty, Color.Empty, Color.Empty);
            if (count < 1) return;
            switch (count)
            {
                case 1:
                    order.Tension1 = lstTension[count - 1];
                    Log("张力值", $"张力1:{order.Tension1}");
                    break;
                case 2:
                    order.Tension2 = lstTension[count - 1];
                    Log("张力值", $"张力2:{order.Tension2}");
                    break;
                case 3:
                    order.Tension3 = lstTension[count - 1];
                    Log("张力值", $"张力3:{order.Tension3}");
                    break;
                case 4:
                    order.Tension4 = lstTension[count - 1];
                    Log("张力值", $"张力4:{order.Tension4}");
                    break;
                case 5:
                    order.Tension5 = lstTension[count - 1];
                    Log("张力值", $"张力5:{order.Tension5}");
                    break;
            }

            double value = Math.Round(lstTension.Average(), 2);
            double valueMax = lstTension.Max();
            double valueMin = lstTension.Min();
            if (order != null) order.TensionValue = value;
            Color color = (upperLimit + lowerLimit > 0 && (value > upperLimit || value < lowerLimit)) ? Color.Red : Color.White;
            Color colorMax = (upperLimit + lowerLimit > 0 && (valueMax > upperLimit || valueMax < lowerLimit)) ? Color.Red : Color.White;
            Color colorMin = (upperLimit + lowerLimit > 0 && (valueMin > upperLimit || valueMin < lowerLimit)) ? Color.Red : Color.White;

            tensionResult = new TensionResult(value, valueMax, valueMin, color, colorMax, colorMin);
            //不合格
            if (color == Color.Red) order.Qualified = false;
        }
        #endregion

        #region 修复台照片删除
        /// <summary>
        /// 删除修复台重复sn图片
        /// </summary>
        private void DeleteRepairImage(string sn)
        {
            //删除文件
            Task.Factory.StartNew(() =>
            {
                string dirPath = Util.CreateSubDir(confMgr.SysConfigParams.SizeRepairImag.SavePath,
                                                            new List<string> { DateTime.Now.ToString("yyyyMMdd"), sn });
                if (!Directory.Exists(dirPath))
                {
                    return;
                }
                string[] array = Directory.GetFiles(dirPath);
                foreach (string text in array)
                {
                    try
                    {
                        API.OutputDebugString("清除文件：" + text + "...");
                        File.Delete(text);
                    }
                    catch (Exception ex)
                    {
                        API.OutputDebugString("Ex1:" + ex.Message);
                    }
                }

                dirPath = Util.CreateSubDir(confMgr.SysConfigParams.DefectRepairImag.SavePath,
                                           new List<string> { DateTime.Now.ToString("yyyyMMdd"), sn });
                if (!Directory.Exists(dirPath))
                {
                    return;
                }
                array = Directory.GetFiles(dirPath);
                foreach (string text in array)
                {
                    try
                    {
                        API.OutputDebugString("清除文件：" + text + "...");
                        File.Delete(text);
                    }
                    catch (Exception ex)
                    {
                        API.OutputDebugString("Ex1:" + ex.Message);
                    }
                }

            });
        }
        #endregion

        #region 启动
        /// <summary>
        /// 自动运行
        /// </summary>
        /// <returns></returns>
        public bool StartRun(Form fatherFrm, string detectOrder, int defectCnt, string productCode, string sn)
        {
            bool ret = true;
            //Log("运行", $"启动自动检测流程---料号：{productCode}，网版编码：{sn}");
            //运行前清除过期图片文件
            //DateTime st = DateTime.Now;
            DelectPictureFile();
            if(CurrProcessIndex < -1)
            {
                Log("运行", "流程报警中，请清除报警，复位启动", WarningEnum.Low);
                return false;
            }
            if ((statusMgr.Status != SystemStsEnum.Standby)&&(statusMgr.Status != SystemStsEnum.Pause))
            {
                Log("运行", "系统非可运行状态", WarningEnum.Low);
                return false;
            }
            //Log("启动", "移动至上料位...");
            //GotoLoadPos();
            if (!CheckPosIsLoadPos())
            {
                Log("运行", "载具不在上料位！请复位到上料位在启动！", WarningEnum.Low);
                FrmDialog.ShowDialog(fatherFrm, $"载具不在上料位！请复位到上料位在启动！", "警告", false);     
                return false;
            }
            if (string.IsNullOrEmpty(productCode))
            {
                Log("运行", "产品料号未选择！", WarningEnum.Low);
                return false;
            }           
            string code = productCode;

            //清空显示
            //scannerGBmpQueue.Clear();
            scannerCBmpQueue.Clear();
            scannerGBmpQueue.Clear();

            lstCompareFailZoomImage.Clear();
            contoursAffineTrans1_Out = null;

            //情况流程记录数据
            ProductPT_HeightBaseNum = 0;
            lstHeight.Clear();
            lstHeightBase.Clear();
            lstLineWidth.Clear();
            lstTension.Clear();
            lstPT.Clear();

            lstTestData.Clear();
            //清空打印内容
            CurrPrintInfos.Clear();
            
            //Log("调试", $"time1:{(DateTime.Now - st).Milliseconds}");
            //st = DateTime.Now;
            int errStep = 0;
            try
            {
                var model = PdtService.GetModelNav(code);
                if (model != null && model.StepInfo != null && model.StepInfo.ProcessList.Count > 0)
                {
                    errStep = 1;
                    //根据产品设置动态加载外观检测模型文件
                    string onnxFile;
                    if (!string.IsNullOrWhiteSpace(model.DefectModelFile))
                        onnxFile = $"{ConfMgr.Instance.SysConfigParams.AIModelPath}\\{model.DefectModelFile}";
                    else
                        onnxFile = $"{ConfMgr.Instance.SysConfigParams.AIModelPath}\\default.onnx";
                    errStep = 2;
                    defectLib.loadModelFile(onnxFile);
    
                    errStep = 3;
                    //判断检测工单号
                    if (confMgr.SysConfigParams.OpenOredrCheck && string.IsNullOrWhiteSpace(detectOrder))
                    {
                        if (FrmDialog.ShowDialog(fatherFrm, $"检测工单为空是否继续？", "提示", true) != DialogResult.OK)
                        {
                            Log("运行", "检测工单号为空！", WarningEnum.Low);
                            return false;
                        }
                        else
                            Log("运行", "检测工单号为空测试");
                    }
                    //判定检测工单数量
                    if (confMgr.SysConfigParams.OpenOredrCntCheck)
                    {
                        var detectOrderList = OrderService.GetListNav(detectOrder);
                        if (detectOrderList != null && detectOrderList.Count >= defectCnt)
                        {
                            if (FrmDialog.ShowDialog(fatherFrm, $"检测工单数量已满 {detectOrderList.Count} 是否继续？", "提示", true) != DialogResult.OK)
                            {
                                Log("运行", "检测工单数量已满！", WarningEnum.Low);
                                return false;
                            }
                            else
                                Log("运行", "检测工单数量已满,继续测试");
                        }
                    }     
                    //输入SN
                    if (string.IsNullOrWhiteSpace(sn))
                    {
                        Log("运行", "网版编码为空！", WarningEnum.Low);
                        return false;
                    }
                    Log("运行", $"料号：{code}，网版编码：{sn}");

                    //记忆sn
                    //Remind(sn);

                    //查询SN是否重复
                    var findSN = OrderService.GetModelNav(sn);
                    errStep = 4;
                    if ((findSN != null)&&(findSN.ProductInfo.Code == model.Code))
                    {
                        Log("运行", $"网版编码：{sn}, 已经存在检测数据！");
                        if(FrmDialog.ShowDialog(fatherFrm, $"网版编码：{sn}, 已经存在检测数据！", "提示", true) != DialogResult.OK)
                        {
                            Log("运行", "网版编码重复测试终止运行！", WarningEnum.Low);
                            return false;
                        }
                        else
                            Log("运行", "网版编码重复测试");
                        //删除已有sn的修复图片
                        DeleteRepairImage(sn);
                    }
                    //Log("调试", $"time3:{(DateTime.Now - st).Milliseconds}");
                    //st = DateTime.Now;
                    errStep = 5;

                    //判断SN数量是否达到批次上限
                    //创建表达式
                    if (!string.IsNullOrWhiteSpace(model.BatchId) && model.TargetCount > 0)
                    {
                        var exp1 = Expressionable.Create<Order>()
                            .And(m => m.ProductId == model.Id)
                            .And(m => m.BatchId == model.BatchId)
                            .And(m => m.SN != sn)
                            .ToExpression();//注意 这一句 不能少
                        errStep = 6;
                        if (OrderService.Count(exp1) >= model.TargetCount)
                        {
                            Log("运行", $"当前产品本批次检测数已达目标数量，请更换检测批次号!", WarningEnum.Low);
                            return false;
                        }

                        errStep = 7;
                    }

                    //判断是否清空工单打印的数据
                    if(model.EnableOrderPrint)
                    {
                        CurrDefectOrders = OrderService.GetListNav(detectOrder);
                        if (CurrDefectOrders == null || CurrDefectOrders.Count == 0)
                        {
                            Log("运行", "当前工单未测试，清空所有工单数据！");
                            CurrOrderPrintInfos.Clear();
                            CurrDefectIndex = 0;
                        }
                        else
                        {
                            CurrDefectIndex = CurrDefectOrders.Count; 
                        }
                        Log("运行", $"当前工单第{CurrDefectIndex + 1}块，开始测试！");
                    }
                    

                    //Log("调试", $"time4:{(DateTime.Now - st).Milliseconds}");
                    //st = DateTime.Now;
                    //界面显示SN
                    model.HeightBaseDec = "";
                    CurrProductModel = model;
                    Log("运行", $"{model.Name} {model.Spec} [{model.Code}]");

                    //新旧流程判断
                    if (model.StepInfo.ProcessType != "快速流程")
                    {
                        IsNewStepProcessVel = false;
                        OnAutoRuning(new RunEventArgs(sn, model.StepInfo.ProcessList));
                    }
                    else
                    {
                        IsNewStepProcessVel = true;
                        OnAutoRuning(new RunEventArgs(sn, model.StepInfo.ProcessList, true));
                    }

                    
                    forLib.clear();
                    ifLib.clear();

                    TotalCnt = defectCnt;
                    errStep = 8;
       
                    order = new Order();
                    order.Qualified = true;//默认合格，中间有一项指标不合格则改为false
                    order.ProductId = CurrProductModel.Id;
                    order.StepId = (int)CurrProductModel.StepId;

                    order.XPTValue = 0;

                    order.DetectOrder = detectOrder;
                    
                    order.OrderCode = productCode;

                    order.SN = sn;
                    order.BatchId = CurrProductModel.BatchId;
                    errStep = 9;
                    AllDefectCount = 0;
                    SizeNGCnt = 0;
                    defectBmpNumResult = defectBmpNum = compBmpNum =  compBmpIndex = 0;

                    IsCurrHeightBase = false;

                    //加载产品需要打印的内容
                    if (model.PrintInfoList != null)
                        CurrPrintInfos = new List<PrintInfo>(model.PrintInfoList.ToArray()); // copy
                    if (model.EnableOrderPrint && model.PrintInfoList != null && CurrOrderPrintInfos.Count == 0)
                    {
                        Log("运行", $"获取打印工单信息{CurrDefectIndex}！");
                        CurrOrderPrintInfos = new List<PrintInfo>(model.PrintInfoList.ToArray()); // copy
                    }

                    //RunQG(true);
                    //新流程判断是否测厚度，是的话开启基准检测
                    if (IsNewStepProcessVel)
                    {
                        bool openHeightBaseTest = false;
                        string baseParams = "";
                        string processName = "";
                        foreach (var item in model.StepInfo.ProcessList)
                        {
                            if((item.ProcessCode == "Height")&&(!confMgr.SysConfigParams.DisableThickness))
                            {
                                processName = item.ProcessName;
                                baseParams = item.ProcessParams;
                                ThicknessProp Param = JsonConvert.DeserializeObject<ThicknessProp>(item.ProcessParams);
                                
                                openHeightBaseTest = !Param.Disable;
                                break;
                            }
                        }
                        if (openHeightBaseTest)
                        {
                            if (SizeEnable)
                            {
                                if (HeightProcessTest(0, processName, baseParams, true) < 0)
                                    return false;
                            }
                        }
                    }

                    //Log("启动", "8");
                    IsGetStartSig = false;
                    CurrProcessIndex = 0;
                    CurrPoinntCount = 0;
                    CurrStepResult = 0;
                    LedRun();
                    stopWatch = new Stopwatch();
                    _isRuning = true;
                    _isAuto = true;
                    statusMgr.GotoAuto();
                    SendStatus();
                    errStep = 10;

                    //Log("调试", $"time5:{(DateTime.Now - st).Milliseconds}");
                    //st = DateTime.Now;
                    //调试，可删
                    //CurrDefectOrders = OrderService.GetListNav(order.DetectOrder);
                    //if (model.EnableOrderPrint && (CurrDefectOrders.Count == TotalCnt))
                    //{
                    //    Log("工单打印", $"打印机:{confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={model.OrderTempPath}");

                    //    ret = PrintFileOrderData(confMgr.SysConfigParams.ExcelPrinterName,
                    //        model.OrderTempPath, CurrOrderPrintInfos, model);
                    //    if (ret)
                    //        Log("工单打印", $"打印成功！");
                    //    else
                    //        Log("工单打印", $"打印失败:打印机={confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={model.OrderTempPath}, 打印数据={CurrOrderPrintInfos}", WarningEnum.Low);
                    //}

                }
                else
                    Log("运行", model != null ? $"料号{code}不存在!" : $"产品({model.Name})未配置检测流程!", WarningEnum.Low);
            }
            catch (Exception ex)
            {
                Log("运行", $"程序错误-{errStep}:" + ex.Message + "\n", WarningEnum.High);
            }
                
            return ret;
        }
        /// <summary>
        /// 暂停重启
        /// </summary>
        /// <returns></returns>
        public bool ReStartRun()
        { 
            bool ret = false;
            if (CurrProcessIndex >= 1 )
            {
                Log("启动", $"暂停 -> 继续 当前工序索引：{CurrProcessIndex + 1}");
                LedRun();
                _isRuning = true;
                statusMgr.GotoAuto();
                SendStatus();
                ret = true;
            }
            return ret;
        }
        #endregion

        #region 报警等、按钮IO
        /// <summary>
        /// 三色灯报警状态显示
        /// </summary>
        /// <returns></returns>
        public bool WarningShowLed(bool DisEnableBuzz)
        {
            bool sts = false;
            if (statusMgr.Warning == WarningEnum.Normal)
            {
                if(statusMgr.Status == SystemStsEnum.Auto)
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), true);
                else
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                if (statusMgr.Status == SystemStsEnum.Pause)
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);
                else
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);
                BuzzCnt = 0;
                //判断黄灯是否需要闪烁，调用200ms一次
                if (Blink)
                {
                    if(BlinkCnt < 3)
                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), true);
                    else if(BlinkCnt < 6)
                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
                    BlinkCnt++;
                    if (BlinkCnt == 6)
                        BlinkCnt = 0;
                }
                else
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), false);
            }
            if (statusMgr.Warning == WarningEnum.Low)
            {
                //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
                //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);
                //ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                //sts = true;
            }
            if (statusMgr.Warning == WarningEnum.High)
            {
                sts = true;
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                if (confMgr.SysConfigParams.OpenBuzzer && !DisEnableBuzz)
                {
                    if(BuzzCnt < 3)
                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), true);
                    else if (BuzzCnt < 6)
                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);
                    BuzzCnt++;
                    if (BuzzCnt == 6)
                        BuzzCnt = 0;
                }
            }
            return sts;
        }
        /// <summary>
        /// 按钮IO检测
        /// </summary>
        /// <returns></returns>
        public int  ButtonIOTrg(bool DisEnableDoorAlm)
        {
            int ret = 0;
            bool sts;
            if(confMgr.SysConfigParams.OpenDoor && !DisEnableDoorAlm)
            {
                ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.门磁), GetIOBitIndex((int)DIName.门磁), out sts);
                if ((!sts)&&(statusMgr.Status == SystemStsEnum.Auto))
                {
                    Log("暂停", "门磁报警-门打开", WarningEnum.Low );
                    statusMgr.GotoPause();
                    SendStatus();
                    ret = 2;
                }
            }
            ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.暂停按钮), GetIOBitIndex((int)DIName.暂停按钮), out sts);
            if (sts)
            {
                Log("暂停", "手动暂停");
                statusMgr.GotoPause();
                SendStatus();
                ret = 2;
            }
            ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.复位按钮), GetIOBitIndex((int)DIName.复位按钮), out sts);
            if (sts)
            {
                ret = 3;
                //if (SysMgr.Instance.StatusMgr.Status == SystemStsEnum.Warning)
                //{
                //    Log("清除", "手动清除报警");
                //    if (SysMgr.Instance.IsAuto)
                //        SysMgr.Instance.StatusMgr.GotoPause();
                //    else
                //        SysMgr.Instance.StatusMgr.GotoNormalStandby();
                //}           
            }
            ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.启动按钮), GetIOBitIndex((int)DIName.启动按钮), out sts);
            if (sts)
                ret = 1;
            //张力触发按钮
            ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.触发张力), GetIOBitIndex((int)DIName.触发张力), out sts);
            if ((sts) && (!IsNewStepProcessVel))
                ret = 4;
            else if ((sts) && (IsNewStepProcessVel))
            {
                ret = 5;
            }

            return ret ;
        }
        #endregion

        #region 手动回原
        /// <summary>
        /// 设备硬件重新加载
        /// </summary>
        public void AllResetAndGoHome()
        {
            try
            {
                Log("复位", "系统硬件重置-关闭");

                if(_isInit)
                    lensMotorDev.CloseBoard();
                _isInit = false;
                _isAuto = false;
                _isRuning = false;

                
                statusMgr.ClearWarning();
                AxisDStop();
                axisDev.CloseBoard();
                ioCardDev.ResetAllDO();
                ioCardDev.CloseBoard();
                lightDev.CloseDev();

                thicknessDev.CloseDev();
                tensionDev.CloseDev();
               
                //Thread.Sleep(500);
                System.GC.Collect();
                for (int i = 0; i < 30; i++)
                {
                    System.Windows.Forms.Application.DoEvents();
                    Thread.Sleep(100);
                }
                //System.Windows.Forms.Application.DoEvents();
                //Thread.Sleep(500);
                //System.Windows.Forms.Application.DoEvents();
                //Thread.Sleep(500);
                //System.Windows.Forms.Application.DoEvents();

                lensMotorDev = new PmsMotion();

                camDevFront.CloseCamera();
                camDevFront = new CamDev(SysUseCamFront, confMgr.SysConfigParams.FrontCamName, confMgr.SysConfigParams.FrontCamCfgPath);

                camDevBack.CloseCamera();
                camDevBack = new CamDev(SysUseCamBack, confMgr.SysConfigParams.BackCamName, confMgr.SysConfigParams.BackCamCfgPath);

                

                Log("复位", "系统硬件重置-初始化");
                Log("复位", "IO板卡初始化");
                if (ioCardDev.InitBoard(MaiMuControl.Device.IOBordType.Advantech) < 0)
                {
                    Log("IO板卡初始化失败！", "初始化", WarningEnum.High);
                    return;
                }
                if (ioCardDev.OpenBoard(confMgr.SysConfigParams.IODevName, confMgr.SysConfigParams.IOCfgPath) < 0)
                {
                    Log("打开IO板卡失败！", "初始化", WarningEnum.High);
                    return;
                }
                if (ioCardDev.ResetAllDO() < 0)
                {
                    Log("IO Reset失败！", "初始化", WarningEnum.High);
                    return;
                }
                statusMgr.GotoInitial();
                SendStatus();
                statusMgr.ClearWarning();
                _isInit = true;

                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.复位按钮黄灯), GetIOBitIndex((int)DOName.复位按钮黄灯), true);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯黄灯), GetIOBitIndex((int)DOName.三色灯黄灯), true);

                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯绿灯), GetIOBitIndex((int)DOName.三色灯绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯红灯), GetIOBitIndex((int)DOName.三色灯红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.三色灯蜂鸣器), GetIOBitIndex((int)DOName.三色灯蜂鸣器), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.启动按钮绿灯), GetIOBitIndex((int)DOName.启动按钮绿灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.停止按钮红灯), GetIOBitIndex((int)DOName.停止按钮红灯), false);
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);

                //电机初始化
                Log("复位", "运动控制板卡初始化");
                if (axisDev.InitBoard() < 0)
                {
                    Log("运动控制板卡初始化失败！", "初始化", WarningEnum.High);
                    return;
                }
                if (axisDev.OpenBoard(0, confMgr.SysConfigParams.MotionCfgPath) < 0)
                {
                    Log("打开运动控制板卡失败！", "初始化", WarningEnum.High);
                    return;
                }
                if (axisDev.LoadBoardParams(0, boardCfgParams) < 0)
                {
                    Log("载入运动控制板卡参数失败1！", "初始化", WarningEnum.High);
                    return;
                }

                //光源初始化
                Log("复位", "光源控制器初始化");
                int com_num = int.Parse(confMgr.SysConfigParams.LightCom.Remove(0, 3));
                if (lightDev.InitDev(com_num, confMgr.SysConfigParams.LightComBaud) < 0)
                {
                    Log("光源控制器初始化失败！", "初始化", WarningEnum.High);
                    return;
                }

                //张力传感器初始化
                Log("复位", "张力传感器初始化");
                if (tensionDev.OpenDevByCom(confMgr.SysConfigParams.TensionCom, confMgr.SysConfigParams.TensionComBaud) < 0)
                {
                    Log("张力传感器初始化失败！", "初始化", WarningEnum.High);
                    return;
                }
                //InitLog("初始化张力传感器成功！");

                //镜头电机初始化
                Log("复位", "镜头电机初始化");
                lensMotorDev.InitBoard();
                if (lensMotorDev.OpenBoardByCom(confMgr.SysConfigParams.LensMotorCom, confMgr.SysConfigParams.LensMotorComBaud) < 0)
                {
                    Log("镜头电机初始化失败！", "初始化", WarningEnum.High);
                    return;
                }

                //测厚传感器初始化
                Log("复位", "测厚传感器初始化");
                if (thicknessDev.OpenDevByTcp(confMgr.SysConfigParams.ThicknessIP, confMgr.SysConfigParams.ThicknessPort) < 0)
                {
                    Log("测厚传感器初始化失败！", "初始化", WarningEnum.High);
                    return;
                }

                //相机初始化
                Log("复位", "前部相机初始化");
                if (!camDevFront.InitCamera())
                {
                    Log("前部相机初始化失败！", "初始化", WarningEnum.High);
                    return;
                }
                if (!camDevFront.OpenCamera())
                {
                    Log("前部相机打开失败！", "初始化", WarningEnum.High);
                    return;
                }
                Log("复位", "后部相机初始化");
                if (!camDevBack.InitCamera())
                {
                    Log("后部相机初始化失败！", "初始化", WarningEnum.High);
                    return;
                }
                if (!camDevBack.OpenCamera())
                {
                    Log("后部相机打开失败！", "初始化", WarningEnum.High);
                    return;
                }
                Log("复位", "系统硬件重置-回原");
                //镜头电机回原
                lensMotorDev.BackHome(0, new HomeVelocityParams());
                lensMotorDev.CheckHomeDone(0, 3000);
                //移动到 4.5X
                //lensMotorDev.MoveAbsPulse(0, new VelocityCurveParams(), (int)SmallAxCmdPos.倍率4_5X);
                //lensMotorDev.CheckDone(0, 5000);

                //移动Axis前等待厚度传感器收回
                if (thicknessDev.GetValue() < Math.Abs(confMgr.SysConfigParams.ThicknessSafeValue))
                {
                    Log("厚度传感器不在安全位置！", "初始化", WarningEnum.High);
                    return;
                }

                //多轴回原
                if ((homeParamsZ != null) && (homeParamsX1 != null) && (homeParamsX2 != null) && (homeParamsY != null))
                {
                    axisDev.ResetAxisState((int)AxisName.Axis0);
                    axisDev.ResetAxisState((int)AxisName.Axis1);
                    axisDev.ResetAxisState((int)AxisName.Axis2);
                    axisDev.ResetAxisState((int)AxisName.Axis3);
                    Log("复位", "Z轴开始回原点...");
                    axisDev.BackHome((int)AxisName.Axis3, homeParamsZ);
                    Log("复位", "X1轴开始回原点...");
                    axisDev.BackHome((int)AxisName.Axis0, homeParamsX1);
                    Log("复位", "X2轴开始回原点...");
                    axisDev.BackHome((int)AxisName.Axis1, homeParamsX1);
                    Log("复位", "Y轴开始回原点...");
                    //y轴使用io回原
                    AxisYGoHome();
                }
                Thread.Sleep(1000);
                //判断轴是否回原成功
                if (!AxisYGoHomeDone(60))
                {
                    AxisAllImmediateStop();
                    Log("复位", "Y轴回原失败", WarningEnum.High);
                    return;
                }
                if (axisDev.CheckHomeDone((int)AxisName.Axis0, 60) != 0)
                {
                    AxisAllImmediateStop();
                    Log("复位", "X1轴回原失败", WarningEnum.High);
                    return;
                }
                if (axisDev.CheckHomeDone((int)AxisName.Axis1, 60) != 0)
                {
                    AxisAllImmediateStop();
                    Log("复位", "X2轴回原失败", WarningEnum.High);
                    return;
                }
                if (axisDev.CheckHomeDone((int)AxisName.Axis3, 60) != 0)
                {
                    AxisAllImmediateStop();
                    Log("复位", "Z轴回原失败", WarningEnum.High);
                    return;
                }
                Log("复位", "所有轴回原成功！");

                //清空y轴发送命令和反馈位置
                axisDev.SetCommandPos((int)AxisName.Axis2, 0);
                axisDev.SetFeedbackPos((int)AxisName.Axis2, 0);

                //X轴标定启用
                if (confMgr.SysConfigParams.OpenAxisXCalibration)
                {
                    OpenAxisXCal();
                }
                Log("复位", "移动到上料...");

                //Thread.Sleep(1000);
                LedReady();
                GotoLoadPos();

                //初始化成功
                _isInit = true;
                statusMgr.GotoNormalStandby();
                SendStatus();
            }
            catch (Exception e)
            {
                _isInit = false;
                Log("复位", $"重置失败:{e.Message}", WarningEnum.High);
            }
        }
        #endregion

        #region 位置获取
        public string GetAxisPos()
        {
            string posStrng = "";
            double pos1 = axisDev.GetFeedbackPos((int)AxisName.Axis0);
            double pos2 = axisDev.GetFeedbackPos((int)AxisName.Axis1);
            double pos3 = axisDev.GetFeedbackPos((int)AxisName.Axis2);
            double pos4 = axisDev.GetFeedbackPos((int)AxisName.Axis3);
            double cmd1 = axisDev.GetCommandPos((int)AxisName.Axis0);
            double cmd2 = axisDev.GetCommandPos((int)AxisName.Axis1);
            double cmd3 = axisDev.GetCommandPos((int)AxisName.Axis2);
            double cmd4 = axisDev.GetCommandPos((int)AxisName.Axis3);
            posStrng = "[命令位:" + (cmd1 / (double)GetMMtoPlus(AxisName.Axis0)).ToString("0.0000") +
                " 反馈位:" + (pos1 / (double)GetMMtoPlus(AxisName.Axis0)).ToString("0.0000") + "]" +
                "[命令位:" + (cmd2 / (double)GetMMtoPlus(AxisName.Axis1)).ToString("0.0000") +
                " 反馈位:" + (pos2 / (double)GetMMtoPlus(AxisName.Axis1)).ToString("0.0000") + "]" +
                "[命令位:" + (cmd3 / (double)GetMMtoPlus(AxisName.Axis2)).ToString("0.0000") +
                " 反馈位:" + (pos3 / (double)GetMMtoPlus(AxisName.Axis2)).ToString("0.0000") + "]" +
                "[命令位:" + (cmd4 / (double)GetMMtoPlus(AxisName.Axis3)).ToString("0.0000") +
                " 反馈位:" + (pos4 / (double)GetMMtoPlus(AxisName.Axis3)).ToString("0.0000") + "]";
            return posStrng;
        }
        #endregion
        
        #endregion

        #region 主流程

        #region 后台
        /// <summary>
        /// 中断工序运行
        /// </summary>
        /// <returns></returns>
        private bool isBreakProcessRun()
        {
            return statusMgr.Status ==  SystemStsEnum.Pause || statusMgr.Warning == WarningEnum.High ;
        }
        /// <summary>
        /// 后台运行主线程
        /// </summary>
        private void MainThreadFunction()
        {
            while (true)
            {
                try
                {
                    if (_cts.IsCancellationRequested)
                        break;
                    
                    if (IsRuning)
                    {
                        //暂停开始
                        stopWatch.Start();
                        do
                        {
                            CurrProcessIndex = nextProcess(CurrProductModel, CurrProcessIndex);
                        } while (CurrProcessIndex >= 0 && !isBreakProcessRun());
                        //暂停中断
                        stopWatch.Stop();   
                        
                        _isRuning = false;
                    }
                    Thread.Sleep(10);
                }
                catch (Exception e) 
                {
                    _isRuning = false;
                    
                    Log("运行报警", "流程运行出错：" + e.Message + "\n", WarningEnum.High); 
                }
            }
        }
        #endregion

        #region 缺陷字典
        /// <summary>
        /// 获取缺陷项阈值
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        private Dictionary<string, float> getProductAreaThreshol(Product m)
        {
            Dictionary<string, float> dic = new Dictionary<string, float>();

            if (!confMgr.SysConfigParams.OpenAsideDefect)
            {
                foreach (var item in m.QualifiedCriterionList)
                    dic.Add(item.DefectCode, (float)(item.Size * 25.4 * 25.4 / m.HoleCount / m.HoleCount));//网目 => mm^2
            }
            else
            {
                foreach (var item in m.QualifiedCriterionList)
                    dic.Add(item.DefectCode, (float)(item.Size * 25.4 / m.HoleCount));//网目 => mm^2
            }
            //dic.Add(item.DefectCode, (float)(item.Size * 25.4 * 25.4 / m.HoleCount / m.HoleCount));//网目 => mm^2


            //全缺陷项
            //foreach (var item in Enum.GetValues(typeof(DefectCodeEnum)))
            //{ 
            //    var code = EnumExtension.GetEnumDescription((DefectCodeEnum)item);
            //    if (!dic.ContainsKey(code))
            //        dic.Add(code, 0);
            //}
            var lstDefect = ConfMgr.GetArrayList<DefectCodeEnum>();
            foreach (DictionaryEntry item in lstDefect)
            {
                string code = item.Value.ToString();
                if (!dic.ContainsKey(code))
                    dic.Add(code, 0);
            }
            return dic;
        }

        //统计缺陷类型  [["92.7542","80.85799","99.54083","86.05363","dk","0.52"]]
        public void countDefectClass(List<string>[] list)
        {
            string className;
            for (int i = 0; i < list.Length; i++)
            {
                className = list[i][4];
                switch (className)
                {
                    case "dk":
                        order.DKCount++;
                        break;
                    case "zw":
                        order.ZWCount++;
                        break;
                    case "gsyc":
                        order.GSYCCount++;
                        break;
                    case "xws":
                        order.XWSCount++;
                        break;
                    case "qk":
                        order.QKCount++;
                        break;
                    case "zk":
                        order.ZKCount++;
                        break;
                    case "pp":
                        order.PPCount++;
                        break;
                    case "hs":
                        order.HSCount++;
                        break;
                    case "yx":
                        order.YXCount++;
                        break;
                    case "xb":
                        order.XBCount++;
                        break;
                    case "sx": //sx 变为 gs
                        order.SXCount++;
                        break;
                    case "ds":
                        order.DSCount++;
                        break;
                    case "gsdl":
                        order.GSDLCount++;
                        break;
                    case "cjdk":
                        order.CJDKCount++;
                        break;
                    default:
                        Log($"数据统计", $"错误参数:{className}", WarningEnum.Low);
                        break;
                }
            }
        }
        
#endregion
        //model.Type=1 系统校正
        /// <summary>
        /// 
        /// </summary>
        /// <param name="model"></param>
        /// <param name="stepIndex">0-n</param>
        /// <returns>大于等于0正常工序； -1:结束 -2：异常</returns>
        private int nextProcess(Models.Product model, int stepIndex)
        {
            try
            {
                //记录当前index
                this.CurrProcessIndex = stepIndex;
                OnAutoRuning(new RunEventArgs(stepIndex));
               
                //判断是否中断或暂停
                if (isBreakProcessRun())
                    return stepIndex;
                
                //开始计时
                if ( model.StepInfo.StartTimeIndex > 0 && model.StepInfo.StartTimeIndex == stepIndex + 1)
                    stopWatch.Restart();

                var processtype = model.StepInfo.ProcessType;
                bool IsNewStep = processtype == "快速流程" ? true: false;
                var processList = model.StepInfo.ProcessList;
                var processInfo = processList[stepIndex];
                string processName = processInfo.ProcessName;
                //当前测试点个数
                int TestCnt = 0;
                //AddTextEvent($"{stepIndex + 1}-{processName}", $"工序开始...");
                string jsonParams = null;//配方

                //使用产品配方
                if (model.ProductProcessList != null && model.ProductProcessList.Count > 0)
                {
                    ProductProcess productProcessParams = model.ProductProcessList.First(m => m.ProcessCode == processInfo.ProcessCode);
                    if (productProcessParams != null)
                    {
                        jsonParams = productProcessParams.ProcessParams;
                        Log($"{stepIndex + 1}-{processName}", $"使用产品专用配方:{jsonParams}");                       
                    }
                }
                //使用流程默认配方
                if (jsonParams == null)
                {
                    jsonParams = processInfo.ProcessParams;
                    if (jsonParams == null) throw new Exception("配方为null!!");
                    if(IsNewStep)
                        Log($"{stepIndex + 1}-{processName}", $"使用 快速流程 默认配方:{jsonParams}");
                    else
                        Log($"{stepIndex + 1}-{processName}", $"使用 高级流程 默认配方:{jsonParams}");
                }

                //加载工序参数
                JObject processParam = JObject.Parse(jsonParams);
                TestCnt = 0;
                bool s_Qualified = true;
                if (!processParam.ContainsKey("Disable") || !processParam.Value<bool>("Disable"))
                {
                    if (!IsNewStep)
                    {
                        #region 老流程/高级流程
                        AutoResetEvent endEvent;
                        uint sleepPre = processParam.Value<uint>("SleepPre");
                        uint sleepLater = processParam.Value<uint>("SleepLater");
                        if (sleepPre > 0)
                            Thread.Sleep((int)sleepPre);
                        double limitThresholdVal, lowerThresholdVal; //Size,Defect

                        //======Switch 工序类型
                        bool asynRun;
                        string gbxBmpPath = "";

                        Models.Attachment attachmentFile;
                        int liStatocStepIndex = stepIndex;
                        switch (processInfo.ProcessCode)
                        {
                            case "IOCard":
                                #region
                                var direction = (IODirectionEnum)processParam.Value<int>("Direction");
                                if (direction == IODirectionEnum.输入 || direction == IODirectionEnum.输入输出)
                                {
                                    uint IN_Waiting_Timeout = processParam.Value<uint>("IN_Waiting_Timeout");
                                    Log($"{stepIndex + 1}-{processName}", $"等待I/O输入信号{(IN_Waiting_Timeout > 0 ? $"(超时时长: {IN_Waiting_Timeout})" : "...")}");
                                    string[] inValue = processParam.Value<JArray>("IN_OP_SHOW").ToObject<List<string>>().ToArray();
                                    uint inWaitingTime = 0;
                                    while (true)
                                    {
                                        if (isBreakProcessRun())
                                            return stepIndex;

                                        byte[] DIData;
                                        ioCardDev.GetDIByteState(out DIData);
                                        if (compareIOInput(inValue, DIData))
                                            break;

                                        Thread.Sleep(10);
                                        inWaitingTime += 10;
                                        if (IN_Waiting_Timeout > 0 && inWaitingTime >= IN_Waiting_Timeout)
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"输入等待超时告警!", WarningEnum.High);
                                            return stepIndex;
                                        }
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"I/O输入信号对比完成！");
                                }

                                if (direction == IODirectionEnum.输出 || direction == IODirectionEnum.输入输出)
                                    io_output($"{stepIndex + 1}-{processName}", processParam);
                                #endregion
                                break;
                            case "Tension":
                                #region
                                Log($"{stepIndex + 1}-{processName}", $"忽略不支持流程！");
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!"));
                                #endregion
                                break;
                            case "Height":
                                #region
                                if (confMgr.SysConfigParams.DisableThickness)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!"));
                                    break;
                                }

                                if (!WaitAllAxisDone())//因启用轴异步功能,使用前需等待
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }

                                limitThresholdVal = processParam.Value<double>("LimitThresholdVal");
                                lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");
                                bool IsRevise = processParam.Value<bool>("IsRevise");
                                double relBaseValue = processParam.Value<double>("RelBaseValue"); //配方中相对偏移值
                                var heightValue = thicknessDev.GetValue();
                                heightValue = Math.Round(heightValue, 2);//保留2位小数

                                
                                File.AppendAllText(Directory.GetCurrentDirectory() + "\\厚度测量记录.txt", heightValue + "\r\n");//TEMP

                                if (!IsRevise && heightValue < 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue}，异常数据，终止任务！", WarningEnum.High);
                                    return stepIndex;
                                }
                                //厚度Base校正
                                if (IsRevise)
                                {
                                    var reviseHeight = heightValue + relBaseValue;
                                    model.HeightBaseDec += reviseHeight + ";";
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"base值:{reviseHeight} = 厚度值:{heightValue}+偏移值:{relBaseValue}"));
                                    Log($"{stepIndex + 1}-{processName}", $"base值:{reviseHeight} = 厚度值:{heightValue}+偏移值:{relBaseValue}，校正索引队列:{model.HeightBaseDec}");
                                }
                                else
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue}，base值:{model.HeightBaseDec}，偏移值:{relBaseValue}，当前base索引:{ProductPT_HeightBaseNum}");
                                    double heightDev = 0;
                                    var heightDev_BaseList = model.HeightBaseDec.Split(new char[] { ';', ',' });
                                    if (heightDev_BaseList.Count() > ProductPT_HeightBaseNum && heightDev_BaseList[ProductPT_HeightBaseNum].Trim() != "")
                                        heightDev = Convert.ToDouble(heightDev_BaseList[ProductPT_HeightBaseNum].Trim());
                                    ProductPT_HeightBaseNum++;

                                    double heightValue2 = Math.Abs(heightDev - heightValue) + relBaseValue;
                                    heightValue2 = Math.Round(heightValue2, 2);
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"厚度值:{heightValue2}"));

                                    lstHeight.Add(heightValue2);
                                    Log($"厚度值", $"厚度{lstHeight.Count}:{heightValue2}");
                                    OnAutoRuning(new RunEventArgs(21, lstHeight, model.HeightBaseValue + model.HeightUpFloatValue, model.HeightBaseValue - model.HeightDownFloatValue));
                                    double HeightValue = Math.Round(lstHeight.Average(), 2);
                                    if (order != null)
                                        order.HeightValue = HeightValue;
                                    if (order != null)
                                    {
                                        if (lstHeight.Count == 1)
                                            order.Height1 = heightValue2;
                                        else if (lstHeight.Count == 2)
                                            order.Height2 = heightValue2;
                                        else if (lstHeight.Count == 3)
                                            order.Height3 = heightValue2;
                                        else if (lstHeight.Count == 4)
                                            order.Height4 = heightValue2;
                                        else if (lstHeight.Count == 5)
                                            order.Height5 = heightValue2;
                                    }

                                    double HeightUpper = model.HeightBaseValue + model.HeightUpFloatValue;
                                    double HeightLower = model.HeightBaseValue - model.HeightDownFloatValue;
                                    if (HeightUpper + HeightLower > 0 && (HeightValue > HeightUpper || HeightValue < HeightLower))
                                        order.Qualified = false;
                                    
                                    if (limitThresholdVal > 0 && heightValue2 >= limitThresholdVal)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue2}，达到上限阀值:{limitThresholdVal}，请进行下料...", WarningEnum.High);
                                        CurrProcessIndex = stepIndex + 1;
                                        return stepIndex;
                                    }
                                    else if (lowerThresholdVal > 0 && heightValue2 < lowerThresholdVal)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue2}，达到下限阀值:{lowerThresholdVal}，请进行下料...", WarningEnum.High);
                                        CurrProcessIndex = stepIndex + 1;
                                        return stepIndex;
                                    }

                                    Log($"{stepIndex + 1}-{processName}", $"厚度值:{heightValue2} (Base值:{heightDev} - 读取数据:{heightValue} + 偏移值:{relBaseValue})");
                                }

                                #endregion
                                break;
                            case "Axis":
                                #region  多轴后遗留问题：暂停后再启动不知哪几个轴已执行
                                JObject processParamTmp = new JObject();
                                //兼容旧版单轴
                                if (!processParam.ContainsKey("0") && !processParam.ContainsKey("1") && !processParam.ContainsKey("2") && !processParam.ContainsKey("3"))
                                {
                                    processParam.Add("Enable", true);
                                    processParamTmp.Add(processParam.Value<int>("AxisIndex").ToString(), processParam);
                                    processParam = processParamTmp;
                                }
                                //支持多轴移动
                                List<int> axisList = new List<int>();
                                foreach (var processParamSub in processParam.Properties())
                                {
                                    processParam = processParamSub.Value as JObject;
                                    Log($"{stepIndex + 1}-{processName}", processParam.ToString());
                                    if (!processParam.ContainsKey("Disable") || !processParam.Value<bool>("Disable"))
                                    {
                                        //asynRun = processParam.Value<bool>("AsynRun");//异步
                                        int AxisIndex = processParam.Value<int>("AxisIndex");
                                        axisList.Add(AxisIndex);
                                        int DeviceType = processParam.Value<int>("DeviceType");

                                        double VelLow = processParam.Value<double>("VelLow");
                                        double VelHigh = processParam.Value<double>("VelHigh");
                                        double Acc = processParam.Value<double>("Acc");
                                        double Dec = processParam.Value<double>("Dec");

                                        AxMoveMode MoveMode = (AxMoveMode)processParam.Value<int>("MoveMode");//绝对位置
                                        double PPUValue = processParam.Value<double>("Value");
                                        Log($"{stepIndex + 1}-{processName}",
                                            $"轴{AxisIndex}准备({(MoveMode == AxMoveMode.绝对位置 ? "绝对" : "相对")})运动至{PPUValue}...");

                                        if (axisDev.CheckDone(AxisIndex, 60) != 0)
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"轴{AxisIndex}到位失败！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                        VelocityCurveParams vel = new VelocityCurveParams(Acc, Dec, VelLow, VelHigh, MotionST, GetMMtoPlus((AxisName)AxisIndex));
                                        int iret = 0;
                                        if (MoveMode == AxMoveMode.绝对位置)
                                            iret = axisDev.MoveAbsValue(AxisIndex, vel, PPUValue);
                                        else
                                            iret = axisDev.MoveRelValue(AxisIndex, vel, PPUValue);
                                        if (iret != 0)
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"轴{AxisIndex}运动失败！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                    }
                                }
                                //多轴同时运行后强制等待各轴完成
                                Log($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

                                if (!WaitAxisDone(axisList))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"轴组运行完成");
                                #endregion
                                break;
                            case "AxisTag":
                                #region
                                //asynRun = processParam.Value<bool>("AsynRun");//异步
                                string axisSizeTag = processParam.Value<string>("SizeTag");
                                int useIndex = processParam.Value<int>("UseIndex");//消费posePT中的索引
                                AxMoveMode TagMoveMode = (AxMoveMode)processParam.Value<int>("MoveMode");//绝对位置
                                var AxisIndexList = processParam.Value<JArray>("AxisIndexList").ToObject<List<int>>();

                                double TagVelLow = processParam.Value<double>("VelLow");
                                double TagVelHigh = processParam.Value<double>("VelHigh");
                                double TagAcc = processParam.Value<double>("Acc");
                                double TagDec = processParam.Value<double>("Dec");
                                //判断有无tag
                                if (order.SizeTagDataList == null)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"数据提供者Tag为空！", WarningEnum.High);
                                    return stepIndex;
                                }

                                var sizeTagObj = order.SizeTagDataList.LastOrDefault(m => m.SizeTag == axisSizeTag);//用最新的last

                                if (sizeTagObj == null)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"偏移校正轴工序找不到数据提供者Tag:{axisSizeTag}！", WarningEnum.High);
                                    return stepIndex;
                                }
                                string[] posePT = sizeTagObj.posePT.Split(',');
                                if (posePT.Length < useIndex + AxisIndexList.Count)
                                {
                                    Log($"{stepIndex + 1}-{processName}",
                                        $"Tag:{axisSizeTag}对应消费索引:{useIndex},Axis数量:{AxisIndexList.Count} 超出postPT:{sizeTagObj.posePT} 范围!", WarningEnum.High);
                                    return stepIndex;
                                }

                                double[] TagPPUValue = new double[AxisIndexList.Count];
                                for (int i = 0; i < AxisIndexList.Count; i++)
                                    TagPPUValue[i] = double.Parse(posePT[useIndex + i]);
                                string axisTagMsg = $"消费Tag:{axisSizeTag},索引:{useIndex}, 轴:{string.Join(",", AxisIndexList.ToList())},数据:{(TagMoveMode == AxMoveMode.绝对位置 ? "绝对" : "相对")}({string.Join(",", TagPPUValue.ToList())})";
                                Log($"{stepIndex + 1}-{processName}", axisTagMsg);
                                //界面显示
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, axisTagMsg));

                                for (int i = 0; i < AxisIndexList.Count && i < TagPPUValue.Length; i++)
                                {
                                    if (axisDev.CheckDone(AxisIndexList[i], 60) != 0)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴{AxisIndexList[i]}到位失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    VelocityCurveParams vel = new VelocityCurveParams(TagAcc, TagDec, TagVelLow, TagVelHigh, MotionST, GetMMtoPlus((AxisName)AxisIndexList[i]));
                                    int iret = 0;
                                    if (TagMoveMode == AxMoveMode.绝对位置)
                                        iret = axisDev.MoveAbsValue(AxisIndexList[i], vel, TagPPUValue[i]);
                                    else
                                        iret = axisDev.MoveRelValue(AxisIndexList[i], vel, TagPPUValue[i]);
                                    if (iret != 0)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴{AxisIndexList[i]}运动失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                if (sizeTagObj.ConsumeStepIndex == null) sizeTagObj.ConsumeStepIndex = "";
                                sizeTagObj.ConsumeStepIndex += $"{stepIndex + 1}-{useIndex}, ";//消费工序ID

                                //多轴同时运行后强制等待各轴完成
                                Log($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

                                if (!WaitAxisDone(AxisIndexList))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"轴组运行完成");

                                #endregion
                                break;
                            case "Light":
                                #region 
                                if (confMgr.SysConfigParams.DisableLight)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    //界面显示
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!"));
                                    break;
                                }
                                int ChannelIndex = processParam.Value<int>("ChannelIndex"); //通道
                                int DigitalValue = processParam.Value<int>("DigitalValue"); //亮度
                                int nowDiaitalValue = lightDev.GetLightDigitalValue(ChannelIndex);
                                Log($"{stepIndex + 1}-{processName}", $"通道{ChannelIndex}当前值:{nowDiaitalValue},准备更新值:{DigitalValue}...");
                                lightDev.SetLightDigitalValue(ChannelIndex, DigitalValue);
                                nowDiaitalValue = lightDev.GetLightDigitalValue(ChannelIndex);
                                Log($"{stepIndex + 1}-{processName}", $"通道{ChannelIndex}更新后当前值:{nowDiaitalValue}。");
                                #endregion
                                break;
                            case "Scanner_GENTL":
                                #region
                                if (confMgr.SysConfigParams.DisableBackCam)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    //界面显示
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!"));
                                    break;
                                }

                                AIEngineLibEnum AIEngineLib = AIEngineLibEnum.缺陷库;
                                if (processParam.ContainsKey("AIEngineLib"))
                                    AIEngineLib = (AIEngineLibEnum)processParam.Value<int>("AIEngineLib");
                                float ExposureTime = processParam.Value<float>("ExposureTime"); //曝光
                                float Gain = processParam.Value<float>("Gain"); //增益
                                float ResultingFrameRate = processParam.Value<float>("ResultingFrameRate"); //帧率

                                Log($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");
                                CamDevBack.SetExposure(ExposureTime);
                                CamDevBack.SetGain(Gain);
                                CamDevBack.SetResultingFrameRate(ResultingFrameRate);

                                DateTime dt = DateTime.Now;
                                CamDevBack.ClearImageQueue();
                                Acquisition acq = CamDevBack.Snap(1, 5000);
                                if (acq.GrabStatus != "GrabPass")
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"后部相机采集照片失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"后部相机采集照片完成[" + (DateTime.Now - dt).Milliseconds.ToString() + "ms]");
                                //显示
                                OnAutoRuning(new RunEventArgs(1, acq.Image));
                                //----缺陷队列

                                if (AIEngineLib == AIEngineLibEnum.缺陷库 || AIEngineLib == AIEngineLibEnum.缺陷与测量库)
                                {

                                    var mat = CamDev.HImageToMat(acq.Image);
                                    scannerGBmpQueue.Enqueue(new scannerGBmpLoc(mat,
                                        GetAxisPosValueMM((int)AxisName.Axis1),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue 
                                    Log($"{stepIndex + 1}-{processName}", $"缺陷图像队列数量: {scannerGBmpQueue.Count}");
                                }
                                if (AIEngineLib == AIEngineLibEnum.测量库 || AIEngineLib == AIEngineLibEnum.缺陷与测量库)
                                {
                                    scannerCBmpQueue.Enqueue(new scannerCBmpLoc(
                                        acq.Image.Clone(),
                                        GetAxisPosValueMM((int)AxisName.Axis1),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue
                                    Log($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，" +
                                        $"X:{GetAxisPosValueMM((int)AxisName.Axis1)},y:{GetAxisPosValueMM((int)AxisName.Axis2)}," +
                                        $"数量: {scannerCBmpQueue.Count}");
                                }

                                #endregion
                                break;
                            case "Scanner_CC":
                                #region                        
                                if (confMgr.SysConfigParams.DisableFrontCam)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!"));
                                    break;
                                }
                                if (!WaitAllAxisDone())//因启用轴异步功能,使用前需等待
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }

                                float ExposureTimeCC = processParam.Value<float>("ExposureTime"); //曝光
                                float GainCC = processParam.Value<float>("Gain"); //增益
                                float ResultingFrameRateCC = processParam.Value<float>("ResultingFrameRate"); //帧率
                                CamDevFront.SetExposure(ExposureTimeCC);
                                CamDevFront.SetGain(GainCC);
                                CamDevFront.SetResultingFrameRate(ResultingFrameRateCC);

                                Log($"{stepIndex + 1}-{processName}", $"相机参数设置完成。");

                                bool tAutoFocus = true;
                                double tFocusStep = 0.02;
                                double tDirStep = 0.04;
                                int tWaitTime = 200;
                                int tTimeOut = 30000;

                                try
                                {
                                    tAutoFocus = processParam.Value<bool>("AutoFocus");
                                    tFocusStep = processParam.Value<double>("FocusStep");
                                    tDirStep = processParam.Value<double>("DirStep");
                                    tWaitTime = processParam.Value<int>("WaitTime");
                                    tTimeOut = processParam.Value<int>("TimeOut");
                                    if((tAutoFocus == false)&&(tFocusStep == 0) && (tDirStep == 0) && (tWaitTime == 0) && (tTimeOut == 0))
                                    {
                                        tAutoFocus = true;
                                        tFocusStep = 0.02;
                                        tDirStep = 0.04;
                                        tWaitTime = 200;
                                        tTimeOut = 30000;
                                        Log($"{stepIndex + 1}-{processName}", $"无参数，使用默认参数！");
                                    }
                                }
                                catch
                                {
                                    tAutoFocus = true;
                                    tFocusStep = 0.02;
                                    tDirStep = 0.04;
                                    tWaitTime = 200;
                                    tTimeOut = 30000;
                                    Log($"{stepIndex + 1}-{processName}", $"错误参数，使用默认参数！");
                                }
                                if ((tAutoFocus)&&(ExposureTimeCC > 0))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"开始自动聚焦...");
                                    if (!AutoFocus(tFocusStep, tDirStep, tWaitTime, tTimeOut))
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"自动聚焦失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"自动聚焦完成");
                                }

                                

                                Log($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");
                                

                                DateTime dt0 = DateTime.Now;
                                CamDevFront.ClearImageQueue();
                                Acquisition acq0 = CamDevFront.Snap(1, 5000);
                                if (acq0.GrabStatus != "GrabPass")
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"前部相机采集照片失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"前部相机采集照片完成[" + (DateTime.Now - dt0).Milliseconds.ToString() + "ms]");
                                //显示
                                OnAutoRuning(new RunEventArgs(0, acq0.Image));

                                scannerCBmpQueue.Enqueue(new scannerCBmpLoc(
                                        acq0.Image.Clone(),
                                        GetAxisPosValueMM((int)AxisName.Axis0),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue
                                Log($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，" +
                                    $"X:{GetAxisPosValueMM((int)AxisName.Axis0)},y:{GetAxisPosValueMM((int)AxisName.Axis2)}," +
                                    $"数量: {scannerCBmpQueue.Count}");


                                #endregion
                                break;
                            case "SmallAxis":
                                #region    
                                if (confMgr.SysConfigParams.DisableLensMotor)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!"));
                                    break;
                                }
                                int CmdPos = processParam.Value<int>("CmdPos"); //命令脉冲
                                Log($"{stepIndex + 1}-{processName}", $"开始由起始位置{lensMotorDev.GetFeedbackPos(0)}运动到{CmdPos}...");
                                lensMotorDev.MoveAbsPulse(0, new VelocityCurveParams(), CmdPos);
                                lensMotorDev.CheckDone(0, 10000);
                                Log($"{stepIndex + 1}-{processName}", $"运动完成，当前位置:{lensMotorDev.GetFeedbackPos(0)}");
                                #endregion
                                break;
                            case "Size":
                                #region
                                asynRun = processParam.Value<bool>("AsynRun");//异步
                                limitThresholdVal = processParam.Value<double>("LimitThresholdVal");
                                lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");
                                int sizeIndex = processParam.Value<int>("Index");
                                string sizeTag = processParam.ContainsKey("SizeTag") ? processParam.Value<string>("SizeTag") : "";


                                //2023-10-27
                                bool useMap = false;
                                List<double> getPosList = new List<double>();
                                try
                                {
                                    //是否有新的使用点位
                                    useMap = processParam.Value<bool>("UseMapPoints");
                                    if (useMap)
                                    {
                                        var list = model.GetPointList.Split(',');
                                        List<double> dList = new List<double>();
                                        if (list.Length < 28)
                                        {
                                            for (int i = 0; i < 28; i++)
                                                dList.Add(0);
                                        }
                                        else
                                        {
                                            for (int i = 0; i < list.Length; i++)
                                                dList.Add(double.Parse(list[i]));

                                        }
                                        getPosList = dList;
                                    }
                                    else
                                    {
                                        for (int i = 0; i < 28; i++)
                                            getPosList.Add(0);
                                    }
                                    //getPosList = processParam.Value<JArray>("GetPointList").ToObject<List<double>>();
                                }
                                catch
                                {
                                    for (int i = 0; i < 28; i++)
                                        getPosList.Add(0);
                                }

                                double[] getPosArray = getPosList.ToArray();
                                if (scannerCBmpQueue.Count < 1)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"尺寸检测异常，无源图像!!", WarningEnum.Low);
                                    return stepIndex;
                                }
                                var bmpCBmpQueue = scannerCBmpQueue.Dequeue();
                                Log($"{stepIndex + 1}-{processName}", $"开始尺寸检测，index:{sizeIndex},posX:{bmpCBmpQueue.PosX},posY:{bmpCBmpQueue.PosY},图像队列数量: {scannerCBmpQueue.Count}...");

                                attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);
                                Log($"{stepIndex + 1}-{processName}", $"尺寸检测，index:{sizeIndex},{model.AttachmentList.Count}|{(attachmentFile == null ? "null" : attachmentFile.NameTimestamp + attachmentFile.ExtendName)}");
                                if (attachmentFile != null)
                                {
                                    gbxBmpPath = confMgr.ProjectDir + $"\\{attachmentFile.NameTimestamp}";
                                    if (!File.Exists(gbxBmpPath + attachmentFile.ExtendName))
                                        gbxBmpPath = "";
                                }
                                if ((sizeIndex == 333 || sizeIndex == 777) && gbxBmpPath == "")
                                    Log($"{stepIndex + 1}-{processName}", $"尺寸检测，index:{sizeIndex},图纸不存在！", WarningEnum.Low);
                                //2023-10-27
                                if (useMap && (sizeIndex == 3333) && (getPosArray != null) && (getPosArray.Count() == 28) && (getPosArray[0] != 0))
                                    Log($"{stepIndex + 1}-{processName}", $"开始图纸读点，index:{sizeIndex},PT1:{getPosArray[0]},PT2:{getPosArray[2]},PT3:{getPosArray[4]},PT4:{getPosArray[6]},PT5:{getPosArray[8]}," +
                                        $"线宽1:[{getPosArray[10]},{getPosArray[11]}],线宽2:[{getPosArray[12]},{getPosArray[13]}],线宽3:[{getPosArray[14]},{getPosArray[15]}]," +
                                        $"线宽4:[{getPosArray[16]},{getPosArray[17]}],线宽5:[{getPosArray[18]},{getPosArray[19]}],线宽6:[{getPosArray[20]},{getPosArray[21]}]," +
                                        $"线宽7:[{getPosArray[22]},{getPosArray[23]}],线宽8:[{getPosArray[24]},{getPosArray[25]}],线宽9:[{getPosArray[26]},{getPosArray[27]}]");
                                //需要偏移校正，index=0时不能异步 //10,20,30...　
                                endEvent = new AutoResetEvent(false);
                                SizeLib.add(new SizeTask()
                                {
                                    stepIndex = stepIndex,
                                    processName = processName,
                                    sizeTag = sizeTag,
                                    engineName = processParam.Value<string>("EngineName"),
                                    Himage = bmpCBmpQueue.Himage.Clone(),//bmp/file_path二选一，优先bmp
                                    file_path = bmpCBmpQueue.Path,
                                    drawingPagePath = gbxBmpPath,
                                    posX = bmpCBmpQueue.PosX,
                                    posY = bmpCBmpQueue.PosY,
                                    //2023-10-27
                                    PTandLinePos = getPosArray,
                                    index = sizeIndex,// scannerCBmpIndex++,
                                    ContoursAffineTrans1_Out = this.contoursAffineTrans1_Out,//只有777时才使用最近333输出的结果 
                                    finishEvent = (res) =>
                                    {
                                        try
                                        {
                                            //比对
                                            if (res.index == 777)//比对
                                            {
                                                if (res.isSucceed)
                                                {
                                                    //界面显示
                                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}-{compBmpIndex}，posX:{res.posX},posY:{res.posY},图像比对:{(res.CompResult ? "通过" : "未通过")} "));
                                                    Log($"{res.stepIndex + 1}-{res.processName}", $"图像比对，index:{res.index}-{compBmpIndex},posX:{res.posX},posY:{res.posY}，结果:{(res.CompResult ? "通过" : "未通过")}");
                                                    // 
                                                    if (order.CompareResult < 2)
                                                        order.CompareResult = res.CompResult ? 1 : 2;
                                                    if (!res.CompResult)
                                                    {
                                                        //不合格
                                                        order.Qualified = false;
                                                    }
                                                    //更新比对看板 对比置零3
                                                    if (!res.CompResult)
                                                        SizeNGCnt++;
                                                    if (SizeNGCnt > 0)
                                                        OnAutoRuning(new RunEventArgs(3, false, SizeNGCnt));
                                                    else
                                                        OnAutoRuning(new RunEventArgs(3, true, SizeNGCnt));
                                                    if (!res.CompResult)
                                                    {
                                                        Log($"{res.stepIndex + 1}-{res.processName}", $"图像比对，未通过结果:{JsonConvert.SerializeObject(res.defectInfor2RestorationDesk)}");
                                                        //转为图纸上坐标位置
                                                        if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)
                                                        {
                                                            //AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"转换到图纸后坐标数据：{JsonConvert.SerializeObject(res.defectInfor2RestorationDeskPage)}");
                                                            if (order.DefectInfoList == null)
                                                                order.DefectInfoList = new List<DefectInfo>();
                                                            foreach (var item in res.defectInfor2RestorationDeskPage)
                                                                order.DefectInfoList.Add(new DefectInfo()
                                                                {
                                                                    Type = 1,
                                                                    Code = item[3],
                                                                    X = double.Parse(item[1]),
                                                                    Y = double.Parse(item[2]),
                                                                    ZXD = double.Parse(item[4]),
                                                                    Index = int.Parse(item[0]),
                                                                    ModifyUserCode = userMgr.LoginUser.Code,
                                                                    CreateUserCode = userMgr.LoginUser.Code,
                                                                });
                                                        }

                                                        //比对失败的图片 -- 用于修复台调用
                                                        Bitmap bmpCompareFailZoomImage = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.Zoom_Image_mat);
                                                        lstCompareFailZoomImage.Add(bmpCompareFailZoomImage);
                                                        if (confMgr.SysConfigParams.SizeRepairImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeRepairImag.SavePath))
                                                        {
                                                            string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeRepairImag.SavePath,
                                                                new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                            //path += $"Size_SN{order.SN}_I{res.index}_X{res.Defects_X}_Y{res.Defects_Y}_C0_{ model.StepInfo.Name}";
                                                            path += $"Size_SN{order.SN}_I{compBmpIndex}_X{res.posX}_Y{res.posY}_C0_{model.StepInfo.Name}";
                                                            lock (ImageSaveObj)
                                                            {
                                                                bmpCompareFailZoomImage.Save(path + ".bmp", ImageFormat.Bmp);
                                                                if (res.defectInfor2RestorationDesk != null && res.defectInfor2RestorationDesk.Count > 0)
                                                                    File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.defectInfor2RestorationDesk));
                                                            }
                                                        }
                                                        //保存不良原图
                                                        if (confMgr.SysConfigParams.SizeNGImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeNGImag.SavePath))
                                                        {
                                                            string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeNGImag.SavePath,
                                                                new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                            path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{model.StepInfo.Name}.bmp";
                                                            Log($"{res.stepIndex + 1}-{processName}", $"未通过图片保存:{path}");
                                                            if (res.Himage != null)
                                                                HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                                                            else
                                                                API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    order.CompareResult = 2;
                                                    order.Qualified = false;
                                                    SizeNGCnt++;
                                                    OnAutoRuning(new RunEventArgs(3, false, SizeNGCnt));
                                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}，图像比对失败！"));
                                                    Log($"{res.stepIndex + 1}-{res.processName}", $"图像比对失败，index:{res.index}-{compBmpIndex}.", WarningEnum.Low);
                                                }
                                                compBmpIndex++;
                                            }
                                            //MARK
                                            else if (res.index == 111 || res.index == 222 || res.index == 333 || res.index == 444)
                                            {
                                                Log($"{res.stepIndex + 1}-{processName}", $"Mark点 Index={res.index}，结果记录...");
                                                if (res.index == 333) this.contoursAffineTrans1_Out = res.ContoursAffineTrans1_Out;//不管成功失败都替换
                                                if (res.isSucceed)
                                                {
                                                    Thread.Sleep(100);
                                                    Log($"{res.stepIndex + 1}-{processName}", $"Mark点 Index={res.index}; 当前值：{string.Join(",", res.MarkPointList)}");
                                                    JArray markDatas;
                                                    if (string.IsNullOrWhiteSpace(order.MarkData))
                                                        markDatas = new JArray() { 0, 0, 0, 0, 0, 0, 0, 0 };
                                                    else
                                                        markDatas = JArray.Parse(order.MarkData);
                                                    for (int i = 0; i < res.MarkPointList.Count(); i++)
                                                        if (res.MarkPointList[i] != 0)
                                                            markDatas[i] = res.MarkPointList[i];
                                                    order.MarkData = markDatas.ToString();
                                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}，Mark点:{order.MarkData} "));
                                                    Log($"{res.stepIndex + 1}-{processName}", $"Mark点 Index={res.index};合并后：{order.MarkData}");
                                                }
                                                else
                                                {
                                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}，Mark点计算失败！"));
                                                    Log($"{res.stepIndex + 1}-{processName}", $"Mark点计算失败，index:{res.index}.", confMgr.SysConfigParams.OpenMarkErrorStop ? WarningEnum.High : WarningEnum.Normal);

                                                }

                                                //保存
                                                if (confMgr.SysConfigParams.SizeBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeBigImag.SavePath))
                                                {
                                                    string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                    path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{model.StepInfo.Name}.bmp";
                                                    if (res.Himage != null)
                                                        HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                                                    else
                                                        API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                                                }
                                            }
                                            else
                                            {
                                                int roundIndex = res.index % 10;
                                                if (res.isSucceed)
                                                {
                                                    string tagOutData = "";
                                                    if (res.index == 3333 && !string.IsNullOrWhiteSpace(res.sizeTag))
                                                    {
                                                        tagOutData = $"Tag:{res.sizeTag},posePT:[{string.Join(",", res.posePT)}]";
                                                        if (res.posePT.Length < 2 || res.posePT.Length % 2 != 0)
                                                        {
                                                            Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测输出Tag对应posePT非法: {tagOutData}", WarningEnum.High);
                                                            return;
                                                        }
                                                        //2023-10-27
                                                        Log($"{res.stepIndex + 1}-{res.processName}", $"Tag对应posePT: {tagOutData}", WarningEnum.Normal);

                                                        if (order.SizeTagDataList == null)
                                                            order.SizeTagDataList = new List<SizeTagData>();
                                                        order.SizeTagDataList.Add(new SizeTagData()
                                                        {
                                                            SizeTag = res.sizeTag,
                                                            CreateStepIndex = res.stepIndex + 1,
                                                            posePT = string.Join(",", res.posePT)// 回转 Array.ConvertAll(sNums , double.Parse);
                                                        });

                                                    }
                                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex,
                                                        $"index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData}"));
                                                    Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测完成 index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData} ");
                                                    //测量
                                                    //------TEST
                                                    if (res.index > 20 && res.index < 30)
                                                    {
                                                        //PT测量
                                                        lock (lstPT)
                                                        {
                                                            lstPT.Add(Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4));
                                                            Log($"PT值", $"PT{lstPT.Count}:{Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4)}");
                                                            OnAutoRuning(new RunEventArgs(22, lstPT, model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue));

                                                            double PtValue = Math.Round(lstPT.Average(), 4);
                                                            if (order != null)
                                                                order.PTValue = PtValue;
                                                            if (order != null)
                                                            {
                                                                if (lstPT.Count == 1)
                                                                    order.PT1 = Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4);
                                                                else if (lstPT.Count == 2)
                                                                    order.PT2 = Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4);
                                                                else if (lstPT.Count == 3)
                                                                    order.PT3 = Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4);
                                                                else if (lstPT.Count == 4)
                                                                    order.PT5 = Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4);
                                                                else if (lstPT.Count == 5)
                                                                    order.PT6 = Math.Round(res.PT1 + confMgr.SysConfigParams.Pt_offset, 4);
                                                            }

                                                            double PtUpper = model.PTBaseValue + model.PTUpFloatValue;
                                                            double PtLower = model.PTBaseValue - model.PTDownFloatValue;
                                                            if (PtUpper + PtLower > 0 && (PtValue > PtUpper || PtValue < PtLower))
                                                                order.Qualified = false;                 
                                                        }
                                                    }
                                                    //------
                                                    if (roundIndex > 0)//1-9测量
                                                    {
                                                        if (res.index < 10)
                                                        {
                                                            //线宽测量
                                                            lock (lstLineWidth)
                                                            {
                                                                double lineWidthValue = res.Shanxian > 0 ? Math.Round(res.Shanxian + confMgr.SysConfigParams.Line_offset, 2) : 0;
                                                                lstLineWidth.Add(lineWidthValue);
                                                                Log($"线宽值", $"线宽{lstLineWidth.Count}:{lineWidthValue}");
                                                                OnAutoRuning(new RunEventArgs(23, lstLineWidth, model.LineWidthBaseValue + model.LineWidthUpFloatValue, model.LineWidthBaseValue - model.LineWidthDownFloatValue));

                                                                double LwValue = Math.Round(lstLineWidth.Average(), 2);
                                                                if (order != null)
                                                                    order.LineWidthValue = LwValue;
                                                                if (order != null)
                                                                {
                                                                    if (lstLineWidth.Count == 1)
                                                                        order.LineWidth1 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 2)
                                                                        order.LineWidth2 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 3)
                                                                        order.LineWidth3 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 4)
                                                                        order.LineWidth4 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 5)
                                                                        order.LineWidth5 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 6)
                                                                        order.LineWidth6 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 7)
                                                                        order.LineWidth7 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 8)
                                                                        order.LineWidth8 = lineWidthValue;
                                                                    else if (lstLineWidth.Count == 9)
                                                                        order.LineWidth9 = lineWidthValue;
                                                                }
                                                                double LwUpper = model.LineWidthBaseValue + model.LineWidthUpFloatValue;
                                                                double LwLower = model.LineWidthBaseValue - model.LineWidthDownFloatValue;
                                                                if (LwUpper + LwLower > 0 && (LwValue > LwUpper || LwValue < LwLower))
                                                                    order.Qualified = false;
                                                            }
                                                        }
                                                    }
                                                    //校正偏移 10,20,30...:偏移
                                                    else
                                                    {
                                                        AxMoveMode axSizeMode = AxMoveMode.绝对位置;
                                                        double xPos = 0;
                                                        double yPos = 0;
                                                        //绝对偏移 
                                                        if (res.offsetX != 0 || res.offsetY != 0)
                                                        {
                                                            xPos += res.offsetX;
                                                            yPos += res.offsetY;
                                                            Log($"{res.stepIndex + 1}-{res.processName}", $"offsetX/Y绝对校正, 0轴:{xPos}mm, 2轴:{yPos}mm");
                                                        }
                                                        else if (res.Circle_Xmm != 0 || res.Circle_Ymm != 0)//相对偏移校正
                                                        {
                                                            axSizeMode = AxMoveMode.相对位置;
                                                            Log($"{res.stepIndex + 1}-{res.processName}", $"原点相对校正, 0轴:{res.Circle_Xmm}mm, 2轴:{res.Circle_Ymm}mm");
                                                            if (res.Circle_Xmm != 0) xPos = res.Circle_Xmm;
                                                            if (res.Circle_Ymm != 0) yPos = res.Circle_Ymm;
                                                        }
                                                        //当前工序直接移动                                                   
                                                        if (xPos != 0 || yPos != 0)
                                                        {
                                                            ;
                                                        }
                                                    }

                                                }
                                                //失败
                                                else
                                                {
                                                    if((res.index == 3333)||(res.index == 1111)||(res.index == 2222)||(res.index == 4444))
                                                    {
                                                        Log($"{res.stepIndex + 1}-{processName}", $"Mark点计算失败，index:{res.index}.", confMgr.SysConfigParams.OpenMarkErrorStop ? WarningEnum.High : WarningEnum.Normal);
                                                    }
                                                    //------TEST
                                                    if (res.index > 20 && res.index < 30)
                                                    {
                                                        //PT测量
                                                        lock (lstPT)
                                                        {
                                                            lstPT.Add(0);
                                                            Log($"PT值", $"PT{lstPT.Count}:0");
                                                            OnAutoRuning(new RunEventArgs(22, lstPT, model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue));
                                                            double PtValue = Math.Round(lstPT.Average(), 4);
                                                            if (order != null)
                                                                order.PTValue = PtValue;
                                                            if (order != null)
                                                            {
                                                                if (lstPT.Count == 1)
                                                                    order.PT1 = 0;
                                                                else if (lstPT.Count == 2)
                                                                    order.PT2 = 0;
                                                                else if (lstPT.Count == 3)
                                                                    order.PT3 = 0;
                                                                else if (lstPT.Count == 4)
                                                                    order.PT5 = 0;
                                                                else if (lstPT.Count == 5)
                                                                    order.PT6 = 0;
                                                            }
                                                            double PtUpper = model.PTBaseValue + model.PTUpFloatValue;
                                                            double PtLower = model.PTBaseValue - model.PTDownFloatValue;
                                                            if (PtUpper + PtLower > 0 && (PtValue > PtUpper || PtValue < PtLower))
                                                                order.Qualified = false;
                                                        }
                                                    }
                                                    //------
                                                    if (roundIndex > 0)
                                                    {
                                                        if (res.index < 10)
                                                        {
                                                            //线宽测量
                                                            lock (lstLineWidth)
                                                            {
                                                                lstLineWidth.Add(0);
                                                                Log($"线宽值", $"线宽{lstLineWidth.Count}:0");
                                                                OnAutoRuning(new RunEventArgs(23, lstLineWidth, model.LineWidthBaseValue + model.LineWidthUpFloatValue, model.LineWidthBaseValue - model.LineWidthDownFloatValue));

                                                                double LwValue = Math.Round(lstLineWidth.Average(), 2);
                                                                if (order != null)
                                                                    order.LineWidthValue = LwValue;
                                                                if (order != null)
                                                                {
                                                                    if (lstLineWidth.Count == 1)
                                                                        order.LineWidth1 = 0;
                                                                    else if (lstLineWidth.Count == 2)
                                                                        order.LineWidth2 = 0;
                                                                    else if (lstLineWidth.Count == 3)
                                                                        order.LineWidth3 = 0;
                                                                    else if (lstLineWidth.Count == 4)
                                                                        order.LineWidth4 = 0;
                                                                    else if (lstLineWidth.Count == 5)
                                                                        order.LineWidth5 = 0;
                                                                    else if (lstLineWidth.Count == 6)
                                                                        order.LineWidth6 = 0;
                                                                    else if (lstLineWidth.Count == 7)
                                                                        order.LineWidth7 = 0;
                                                                    else if (lstLineWidth.Count == 8)
                                                                        order.LineWidth8 = 0;
                                                                    else if (lstLineWidth.Count == 9)
                                                                        order.LineWidth9 = 0;
                                                                }

                                                                double LwUpper = model.LineWidthBaseValue + model.LineWidthUpFloatValue;
                                                                double LwLower = model.LineWidthBaseValue - model.LineWidthDownFloatValue;
                                                                if (LwUpper + LwLower > 0 && (LwValue > LwUpper || LwValue < LwLower))
                                                                    order.Qualified = false;
                                                            }
                                                        }
                                                    }
                                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"失败:{res.resultInfo}"));
                                                    Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测失败index:{res.index}:{res.resultInfo}");

                                                }

                                                //保存
                                                if (confMgr.SysConfigParams.SizeBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeBigImag.SavePath))
                                                {
                                                    string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                    path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{model.StepInfo.Name}.bmp";
                                                    if (res.Himage != null)
                                                        HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                                                    else
                                                        API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测回调处理异常 index:{res.index}，ex={ex.Message}");
                                        }
                                        endEvent.Set();//roundIndex＝０成功或失败线程返回
                                                       //---
                                        if (res.Himage != null)
                                        {
                                            res.Himage.Dispose();
                                            res.Himage = null;
                                        }
                                        else
                                        {
                                            API.DeleteFile(res.file_path);
                                        }
                                    }
                                });

                                //需等上面异步回调中的相对偏移校正完成再继续
                                if (!asynRun || sizeIndex % 10 == 0)
                                {
                                    if (!endEvent.WaitOne(60000))
                                        Log($"{stepIndex + 1}-{processName}", $"{sizeIndex}等待超时，忽略继续！", WarningEnum.Low);
                                }
                                #endregion
                                break;
                            case "Defect":
                                #region
                                limitThresholdVal = processParam.Value<double>("LimitThresholdVal");
                                lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");
                                if (scannerGBmpQueue.Count < 1)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"缺陷检测异常，无源图像!!", WarningEnum.Low);
                                    return stepIndex;
                                }
                                var bmpLoc = scannerGBmpQueue.Dequeue();
                                Log($"{stepIndex + 1}-{processName}", $"开始缺陷检测，源图索引:{defectBmpNum},图像队列数量: {scannerGBmpQueue.Count}...");
                                string[] aarCut_size = processParam.Value<string>("CutSize").Split(',');
                                string[] aarResize = processParam.Value<string>("Resize").Split(',');
                                //图纸
                                attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);
                                if (attachmentFile != null)
                                {
                                    gbxBmpPath = ConfMgr.Instance.ProjectDir + $"\\{attachmentFile.NameTimestamp}";
                                    if (!File.Exists(gbxBmpPath + attachmentFile.ExtendName)) gbxBmpPath = "";
                                }
                                Log($"{stepIndex + 1}-{processName}", $"图纸路径:{gbxBmpPath}");
                                defectLib.add(new DefectTask()
                                {
                                    stepIndex = stepIndex,
                                    processName = processName,
                                    drawingPagePath = gbxBmpPath,
                                    //index = defectBmpNum++,
                                    index = defectBmpNum,
                                    bmp = bmpLoc.bmp.Clone(),
                                    Xmm = bmpLoc.Xmm,
                                    Ymm = bmpLoc.Ymm,
                                    cut_size = new System.Drawing.Size(Convert.ToInt32(aarCut_size[0]), Convert.ToInt32(aarCut_size[1])),
                                    resize = new System.Drawing.Size(Convert.ToInt32(aarResize[0]), Convert.ToInt32(aarResize[1])),
                                    thresholds = processParam.Value<float>("Thresholds"),
                                    thresholdsClass = processParam.Value<string>("ThresholdsClass"),
                                    recAreaThreshold = getProductAreaThreshol(model), //qxName,面积; qxName,面积; qxName,面积;
                                    finishEvent = (res) =>
                                    {
                                        if (res.isSucceed)
                                        {
                                            //界面显示
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex,
                                                $"源图索引:{res.index}，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}"));
                                            Log($"{res.stepIndex + 1}-{res.processName}", $"缺陷检测完成(源图索引:{res.index})，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}");
                                            string path;
                                            if (res.defectCount > 0)
                                            {
                                                //UI显示小图 (含统计缺陷类型数量)
                                                AllDefectCount += res.informationList.Count;
                                                showDefectSmallBmps(res.bmps_tag, res.bmps_cut, res.Xmm, res.Ymm, res.informationList);
                                                if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)
                                                {
                                                    Log($"{res.stepIndex + 1}-{res.processName}", $"转换后坐标数据：{JsonConvert.SerializeObject(res.defectInfor2RestorationDeskPage)}");
                                                    if (order.DefectInfoList == null)
                                                        order.DefectInfoList = new List<DefectInfo>();
                                                    foreach (var item in res.defectInfor2RestorationDeskPage)
                                                        order.DefectInfoList.Add(new DefectInfo()
                                                        {
                                                            Type = 0,
                                                            Code = item[3],
                                                            X = double.Parse(item[1]),
                                                            Y = double.Parse(item[2]),
                                                            ZXD = double.Parse(item[4]),
                                                            Index = int.Parse(item[0]),
                                                            Area = item.Count > 5 ? double.Parse(item[5]) : 0,
                                                            ModifyUserCode = UserMgr.LoginUser.Code,
                                                            CreateUserCode = UserMgr.LoginUser.Code,
                                                        });
                                                }
                                                //保存原始大图
                                                if (confMgr.SysConfigParams.DefectBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectBigImag.SavePath))
                                                {
                                                    path = Util.CreateSubDir(confMgr.SysConfigParams.DefectBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                    path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{model.StepInfo.Name}";
                                                    lock (ImageSaveObj)
                                                    {
                                                        OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save(path + ".bmp", ImageFormat.Bmp);
                                                        File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.informationList));
                                                    }
                                                }

                                                //保存小图
                                                if (confMgr.SysConfigParams.DefectSmallImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectSmallImag.SavePath))
                                                {
                                                    //2024-03-07 图片index计算
                                                    List<string> indexList = new List<string>();
                                                    if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)
                                                        foreach (var item in res.defectInfor2RestorationDeskPage)
                                                        {
                                                            if (indexList.Count == 0)
                                                                indexList.Add(item[0]);
                                                            else
                                                            {
                                                                if (!indexList.Contains(item[0]))
                                                                    indexList.Add(item[0]);
                                                            }
                                                        }

                                                    path = Util.CreateSubDir(confMgr.SysConfigParams.DefectSmallImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                    path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_{model.StepInfo.Name}";

                                                    if (res.bmps_tag.Count() != indexList.Count)
                                                        Log($"{res.stepIndex + 1}-{res.processName}", $"缺陷图片张数和index对不上：{res.bmps_tag.Count()} - {indexList.Count}", WarningEnum.Low);
                                                    for (int i = 0; i < res.bmps_tag.Count(); i++)
                                                    {
                                                        lock (ImageSaveObj)
                                                        {
                                                            if (res.bmps_tag.Count() != indexList.Count)
                                                                res.bmps_tag[i].Save(path + $"_i{i}_{i}.bmp", ImageFormat.Bmp);
                                                            else
                                                                res.bmps_tag[i].Save(path + $"_i{i}_{indexList[i]}.bmp", ImageFormat.Bmp);
                                                        }
                                                        //res.bmps_tag[i].Save(path + $"_i{i}.bmp", ImageFormat.Bmp);
                                                        //res.bmps_tag[i].Save(path + $"{indexList[i]}.bmp", ImageFormat.Bmp);
                                                    }
                                                }

                                                //保存压缩大图 -- 用于修复台调用
                                                if (confMgr.SysConfigParams.DefectRepairImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectRepairImag.SavePath))
                                                {
                                                    path = Util.CreateSubDir(confMgr.SysConfigParams.DefectRepairImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                    path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{model.StepInfo.Name}";
                                                    lock (ImageSaveObj)
                                                    {
                                                        OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmpCompress).Save(path + ".bmp", ImageFormat.Bmp);
                                                        File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.defectInfor2RestorationDesk));
                                                    }
                                                }
                                            }
                                            else//没有缺陷
                                            {
                                                if (confMgr.SysConfigParams.SaveAllImg && confMgr.SysConfigParams.DefectBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectBigImag.SavePath))
                                                {
                                                    path = Util.CreateSubDir(confMgr.SysConfigParams.DefectBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                                    path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{model.StepInfo.Name}";
                                                    lock (ImageSaveObj)
                                                    {
                                                        OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save(path + ".bmp", ImageFormat.Bmp);
                                                    }

                                                }
                                            }
                                        }
                                        else
                                        {
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"失败:{res.resultInfo}"));
                                            Log($"{res.stepIndex + 1}-{res.processName}", $"缺陷检测失败:{res.resultInfo}");
                                            //暂停 这里不能暂停，stepIndex和scannerBmpQueue队列也不对了
                                        }
                                        defectBmpNumResult++;
                                        foreach (var item in res.bmps_cut)
                                            item.Dispose();
                                        res.bmp.Dispose();
                                        res.bmp = null;
                                        res.bmps_tag = null;
                                        if (res.bmpCompress != null)
                                        {
                                            res.bmpCompress.Dispose();
                                            res.bmpCompress = null;
                                        }
                                        System.GC.Collect();
                                    }
                                });
                                defectBmpNum++;
                                #endregion
                                break;
                            case "For":
                                #region
                                long UniqueId = processParam.Value<long>("UniqueId");
                                int GotoStepIndex = processParam.Value<int>("GotoStepIndex");//1-n
                                int LimitNum = processParam.Value<int>("LimitNum");//1-n
                                bool Reset = processParam.Value<bool>("Reset");
                                if (GotoStepIndex - 1 == stepIndex)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"For死循环！！！", WarningEnum.High);
                                    return stepIndex;
                                }
                                if (!forLib.dicData.ContainsKey(UniqueId))
                                    forLib.dicData.Add(UniqueId, 0);
                                //
                                int Num = forLib.dicData[UniqueId];
                                Num++;
                                if (Num <= LimitNum)
                                {
                                    if (Num == LimitNum)
                                    {
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[{Num}/{LimitNum}]次，循环完成"));
                                        Log($"{stepIndex + 1}-{processName}", $"第[{Num}/{LimitNum}]次，循环完成。");
                                    }
                                    else
                                    {
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[{Num}/{LimitNum}]次"));
                                        Log($"{stepIndex + 1}-{processName}", $"第[{Num}/{LimitNum}]次跳转到步骤[{GotoStepIndex}]...");
                                        stepIndex = GotoStepIndex - 2;
                                    }
                                    forLib.dicData[UniqueId] = Num;
                                }
                                else
                                {
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"已失效不执行"));
                                    Log($"{stepIndex + 1}-{processName}", $"本循环已失效不执行！");
                                }

                                //达到limit重置0
                                if (forLib.dicData[UniqueId] >= LimitNum && Reset)
                                {
                                    forLib.dicData[UniqueId] = 0;
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[0/{LimitNum}]次"));
                                    Log($"{stepIndex + 1}-{processName}", $"计数器已重置。");
                                }
                                #endregion
                                break;
                            case "If":
                                #region
                                long UniqueId_if = processParam.Value<long>("UniqueId");
                                int GotoStepIndex_if = processParam.Value<int>("GotoStepIndex");//1-n
                                int LimitNum_if = processParam.Value<int>("LimitNum");//1-n
                                bool Reset_if = processParam.Value<bool>("Reset");
                                if (GotoStepIndex_if - 1 == stepIndex)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"If死循环，不可自我跳转！！！", WarningEnum.High);
                                    return stepIndex;
                                }
                                //
                                if (!ifLib.dicData.ContainsKey(UniqueId_if))
                                    ifLib.dicData.Add(UniqueId_if, 0);
                                //
                                int Num_if = ifLib.dicData[UniqueId_if];
                                Num_if++;
                                if (Num_if <= LimitNum_if)
                                {
                                    if (Num_if == LimitNum_if)
                                    {
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[{Num_if}/{LimitNum_if}]次，跳转至[{GotoStepIndex_if}]"));
                                        Log($"{stepIndex + 1}-{processName}", $"计数器[{Num_if}/{LimitNum_if}]，跳转至步骤[{GotoStepIndex_if}]...");
                                        stepIndex = GotoStepIndex_if - 2;
                                    }
                                    else
                                    {
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[{Num_if}/{LimitNum_if}]次，不跳转"));
                                        Log($"{stepIndex + 1}-{processName}", $"计数器[{Num_if}/{LimitNum_if}]，不跳转。");
                                    }
                                    //
                                    ifLib.dicData[UniqueId_if] = Num_if;
                                }
                                else
                                {
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"已失效不执行"));
                                    Log($"{stepIndex + 1}-{processName}", $"本IF已失效不执行。");
                                }

                                //达到limit重置0
                                if (ifLib.dicData[UniqueId_if] >= LimitNum_if && Reset_if)
                                {
                                    ifLib.dicData[UniqueId_if] = 0;
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[0/{LimitNum_if}]次"));
                                    Log($"{stepIndex + 1}-{processName}", $"计数器已重置。");
                                }
                                #endregion
                                break;
                            default:
                                Log($"{stepIndex + 1}-{processName}", $"未知工序：{processInfo.ProcessCode}", WarningEnum.High);
                                return stepIndex;
                        }
                        if (sleepLater > 0) Thread.Sleep((int)sleepLater);
                        #endregion
                    }
                    else
                    {
                        #region 新流程/快速流程   

                        #region 参数
                        int AxisX1 = (int)AxisName.Axis0;
                        int AxisX2 = (int)AxisName.Axis1;
                        int AxisY = (int)AxisName.Axis2;
                        int AxisZ = (int)AxisName.Axis3;

                        TestCnt = 0;
                        int liStatocStepIndex = stepIndex;
                        int DelayTime = 0;
                        int DataCnt = 0;
                        double OffsetValue = 0;
                        DataProcess dataProcess = DataProcess.均值;
                        DataJudgment judgmentData = DataJudgment.均值;
                        List<PointF> Points = new List<PointF>();
                        double VelLow = 0;
                        double VelHigh = 0;
                        double Acc = 0;
                        double Dec = 0;
                        int WaitTime = 0;

                        double upLimit = 0;
                        double loLimit = 0;
                        List<double> tempDataList = new List<double>();

                        Models.Attachment attachmentFile;
                        string gbxBmpPath = "";

                        List<string> testLabels = new List<string>();
                        Type tp = typeof(PointTestType);
                        FieldInfo[] fieldInfos = tp.GetFields();
                        foreach (var item in fieldInfos)
                        {
                            //不是枚举字段不处理
                            if (item.FieldType.IsEnum)
                            {
                                //名称可以直接获取
                                testLabels.Add(item.Name);
                            }
                        }
                        #endregion
                        switch (processInfo.ProcessCode)
                        {
                            case "Tension":
                                #region 张力测试
                                if (confMgr.SysConfigParams.DisableTensor)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                if (!SizeEnable)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"尺寸检测功能禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"尺寸检测功能禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                TestCnt = processParam.Value<int>("TestCnt");
                                dataProcess = (DataProcess)processParam.Value<int>("ProcessData");
                                DelayTime = processParam.Value<int>("DelayTime");
                                DataCnt = processParam.Value<int>("DataCnt");
                                OffsetValue = processParam.Value<double>("OffsetValue");
                                judgmentData = (DataJudgment)processParam.Value<int>("JudgmentData");
                                TensionProp TensionParam = JsonConvert.DeserializeObject<TensionProp>(jsonParams);
                                //显示当前测试
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, "张力读取", lstTension, 0, 0, 0, 1, false));
                                while (true)
                                {
                                    if (isBreakProcessRun())
                                        return stepIndex;
                                    bool sts = false;
                                    double tensionValue = 0;
                                    double tensionJudgValue = 0;
                                    ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.触发张力), GetIOBitIndex((int)DIName.触发张力), out sts);
                                    if( sts )
                                    {
                                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.触发张力按钮灯), GetIOBitIndex((int)DOName.触发张力按钮灯), true);
                                        tempDataList = new List<double>();
                                        for (int i = 0; i < DataCnt; i++)
                                        {
                                            //Thread.Sleep(DelayTime);
                                            Thread.Sleep(100);
                                            tensionValue = TensionGetValueNewStep();
                                            if (tensionValue < 0)
                                            {
                                                if(tensionValue == -1)                               
                                                    Log("张力读取", "张力读取失败，忽略此次测试!");
                                                else
                                                    Log("张力读取", "张力读取失败且处理失败，忽略此次测试!");
                                                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.触发张力按钮灯), GetIOBitIndex((int)DOName.触发张力按钮灯), false);
                                                return stepIndex;
                                            }
                                            tempDataList.Add( tensionValue );
                                        }
                                        switch(dataProcess)
                                        {
                                            case DataProcess.均值:
                                                tensionValue = tempDataList.Average();
                                                break;
                                            case DataProcess.最大值:
                                                tensionValue = tempDataList.Max();
                                                break;
                                            case DataProcess.最小值:
                                                tensionValue = tempDataList.Min();
                                                break;
                                            default:
                                                tensionValue = tempDataList.Average();
                                                Log("张力读取", "张力读取处理错误,启用均值!");
                                                break;
                                        }
                                        tensionValue = Math.Round(tensionValue, 2);
                                        Log("张力读取", $"张力值:{tensionValue}, 补偿值:{OffsetValue}");
                                        tensionValue = tensionValue + OffsetValue;
                                        lstTension.Add(tensionValue);
                                        Thread.Sleep(200);
                                        //获取判断结果
                                        if (judgmentData == DataJudgment.单点)
                                            tensionJudgValue = tensionValue;
                                        else
                                            tensionJudgValue = Math.Round(lstTension.Average(), 2);

                                        if (TensionParam.OpenUseLimit)
                                        {
                                            upLimit = TensionParam.StandardValues + TensionParam.MaxLimit;
                                            loLimit = TensionParam.StandardValues - TensionParam.MinLimit;
                                        }
                                        else
                                        {
                                            upLimit = CurrProductModel.TensionBaseValue + CurrProductModel.TensionUpFloatValue;
                                            loLimit = CurrProductModel.TensionBaseValue - CurrProductModel.TensionDownFloatValue;
                                        }
                             
                                        if (((upLimit+ loLimit)>0)&&(tensionJudgValue > upLimit) || (tensionJudgValue < loLimit))
                                        {
                                            CurrStepResult = 2;
                                            //order.Qualified = false;
                                        }
                                        else if ((judgmentData == DataJudgment.均值)
                                        && (upLimit + loLimit > 0 && !(tensionJudgValue > upLimit || tensionJudgValue < loLimit)))
                                        {
                                            //order.Qualified = true;
                                            CurrStepResult = 0;
                                        }

                                        order.TensionValue = Math.Round(lstTension.Average(),2);
                                        if (order.SizeDefectInfoList == null)
                                            order.SizeDefectInfoList = new List<SizeDefectInfo>();
                                        order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                        {
                                            result = CurrStepResult == 2 ? 2:1,
                                            X = 0,
                                            Y = 0,
                                            PointCode = processInfo.ProcessCode,
                                            Data = tensionValue,
                                            StepName = processName,
                                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            isAverage = false
                                        });
                                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.触发张力按钮灯), GetIOBitIndex((int)DOName.触发张力按钮灯), false);
                                        //显示数据
                                        if ((TestCnt - 1) == this.CurrPoinntCount) //显示最终结果
                                        {
                                            order.Qualified = CurrStepResult > 0 ? false : order.Qualified;
                                            //记录均值
                                            order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                            {
                                                result = CurrStepResult == 2 ? 2 : 1,
                                                X = 0,
                                                Y = 0,
                                                PointCode = processInfo.ProcessCode,
                                                Data = Math.Round(lstTension.Average(), 2),
                                                StepName = processName,
                                                ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                                CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                                isAverage = true
                                            });
                                            //打印
                                            PrintDataList(processName, TensionParam, CurrProductModel.TensionBaseValue, CurrProductModel.TensionUpFloatValue, CurrProductModel.TensionDownFloatValue);

                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, "张力读取", lstTension, Math.Round(lstTension.Average(), 2),
                                                Math.Round(lstTension.Max(), 2), Math.Round(lstTension.Min(), 2), CurrStepResult > 0 ? 3 : 2, false));
                                        }
                                        else
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, "张力读取", lstTension, Math.Round(lstTension.Average(), 2),
                                                Math.Round(lstTension.Max(), 2), Math.Round(lstTension.Min(), 2), 1, false));
                                        break;
                                    }
                                    Thread.Sleep(100);
                                }
                                Thread.Sleep(DelayTime);
                                #endregion
                                break;
                            case "Height":
                                #region 厚度测试
                                if (confMgr.SysConfigParams.DisableThickness)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, false));           
                                    break;
                                }
                                if (!SizeEnable)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"尺寸检测功能禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"尺寸检测功能禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                //判断厚度基准打完
                                while (true)
                                {
                                    if (isBreakProcessRun())
                                        return stepIndex;
                                    if (IsCurrHeightBase)
                                        break;
                                    Thread.Sleep(100);
                                }
                                //判断是否需要使用双控
                                if(!WaitGetStartSig())
                                {
                                    return stepIndex;
                                }
                                if (!WaitAllAxisDone())//因启用轴异步功能,使用前需等待
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                TestCnt = processParam.Value<int>("TestCnt");
                                dataProcess = (DataProcess)processParam.Value<int>("ProcessData");
                                judgmentData = (DataJudgment)processParam.Value<int>("JudgmentData");
                                DelayTime = processParam.Value<int>("DelayTime");
                                DataCnt = processParam.Value<int>("DataCnt");
                                OffsetValue = processParam.Value<double>("OffsetValue");
                                //Points = processParam.Value<List<PointF>>("Points");
                                ThicknessProp thicknessParam = JsonConvert.DeserializeObject<ThicknessProp>(jsonParams);
                                Points = thicknessParam.Points;

                                VelLow = processParam.Value<double>("VelLow");
                                VelHigh = processParam.Value<double>("VelHigh");
                                Acc = processParam.Value<double>("Acc");
                                Dec = processParam.Value<double>("Dec");
                                WaitTime = processParam.Value<int>("WaitTime");

                                ThicknessProp ThicknessParam = JsonConvert.DeserializeObject<ThicknessProp>(jsonParams);

                                Log($"{stepIndex + 1}-{processName}", processParam.ToString());
                                if (TestCnt > Points.Count)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"点位少于测试次数！", WarningEnum.High);
                                    return stepIndex;
                                }
                           
                                Log($"{stepIndex + 1}-{processName}", $"点位{this.CurrPoinntCount + 1}测试");
                                Log($"{stepIndex + 1}-{processName}",
                                    $"XY准备(绝对)运动至{Points[this.CurrPoinntCount].X},{Points[this.CurrPoinntCount].Y}...");

                                if (axisDev.CheckDone(AxisX1, 20) != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴X1到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                if (axisDev.CheckDone(AxisY, 20) != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴Y到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                VelocityCurveParams velx = new VelocityCurveParams(Acc, Dec, VelLow, VelHigh, MotionST, GetMMtoPlus((AxisName)AxisX1));
                                VelocityCurveParams vely = new VelocityCurveParams(Acc, Dec, VelLow, VelHigh, MotionST, GetMMtoPlus((AxisName)AxisY));
                                int iret1 = 0;
                                int iret2 = 0;
                                iret1 = axisDev.MoveAbsValue(AxisX1, velx, Points[this.CurrPoinntCount].X);
                                iret2 = axisDev.MoveAbsValue(AxisY, vely, Points[this.CurrPoinntCount].Y);
                                if (iret1 != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴X1运动失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                if (iret2 != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴Y运动失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                //多轴同时运行后强制等待各轴完成
                                Log($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");
                                if (axisDev.CheckDone(AxisX1, 20) != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴X1到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                if (axisDev.CheckDone(AxisY, 20) != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴Y到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Thread.Sleep(WaitTime);
                                Log($"{stepIndex + 1}-{processName}", $"轴组运行完成");
                                //测厚气缸下降
                                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), true);
                                Thread.Sleep(confMgr.HeightDoWait);
                                //读取数据
                                double TempVal = 0;
                                tempDataList = new List<double>();
                                for (int j = 0; j < DataCnt; j++)
                                {
                                    Thread.Sleep(DelayTime);
                                    TempVal = thicknessDev.GetValue();                         
                                    tempDataList.Add(TempVal);
                                }
                                switch (dataProcess)
                                {
                                    case DataProcess.均值:
                                        TempVal = tempDataList.Average();
                                        break;
                                    case DataProcess.最大值:
                                        TempVal = tempDataList.Max();
                                        break;
                                    case DataProcess.最小值:
                                        TempVal = tempDataList.Min();
                                        break;
                                    default:
                                        TempVal = tempDataList.Average();
                                        Log("厚度读取", "厚度读取处理错误,启用均值!");
                                        break;
                                }
                                TempVal = Math.Round(TempVal, 2);
                                double TestValue = Math.Round(Math.Abs(lstHeightBase[this.CurrPoinntCount] - TempVal) + OffsetValue,2);
                                Log("厚度读取", $"厚度值{this.CurrPoinntCount + 1}:{TestValue},读取值:{TempVal},基准值:{lstHeightBase[this.CurrPoinntCount]},补偿值:{OffsetValue}");
                                lstHeight.Add(TestValue);
                                //测厚气缸上升
                                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), false);
                                Thread.Sleep(confMgr.HeightDoWait);
                                //获取判断结果
                                double JudgValue;
                                if (judgmentData == DataJudgment.单点)
                                    JudgValue = TestValue;
                                else
                                    JudgValue = Math.Round(lstHeight.Average(), 2);

                                if (ThicknessParam.OpenUseLimit)
                                {
                                    upLimit = ThicknessParam.StandardValues + ThicknessParam.MaxLimit;
                                    loLimit = ThicknessParam.StandardValues - ThicknessParam.MinLimit;
                                }
                                else
                                {
                                    upLimit = CurrProductModel.HeightBaseValue + CurrProductModel.HeightUpFloatValue;
                                    loLimit = CurrProductModel.HeightBaseValue - CurrProductModel.HeightDownFloatValue;
                                }

                                if (((upLimit + loLimit) > 0) && (JudgValue > upLimit) || (JudgValue < loLimit))
                                {
                                    CurrStepResult = 2;
                                    //order.Qualified = false;
                                }
                                else if ((judgmentData == DataJudgment.均值)
                                        && (upLimit + loLimit > 0 && !(JudgValue > upLimit || JudgValue < loLimit)))
                                {
                                    //order.Qualified = true;
                                    CurrStepResult = 0;
                                }

                                order.HeightValue = Math.Round(lstHeight.Average(),2);
                                if (order.SizeDefectInfoList == null)
                                    order.SizeDefectInfoList = new List<SizeDefectInfo>();
                                order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                {
                                    result = CurrStepResult == 2 ? 2 : 1,
                                    X = Points[this.CurrPoinntCount].X,
                                    Y = Points[this.CurrPoinntCount].Y,
                                    PointCode = processInfo.ProcessCode,
                                    Data = TestValue,
                                    StepName = processName,
                                    ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                    CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                    isAverage = false
                                });
                                //显示数据
                                if ((TestCnt - 1) == this.CurrPoinntCount) //显示最终结果
                                {
                                    order.Qualified = CurrStepResult > 0 ? false : order.Qualified;
                                    //记录均值
                                    order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                    {
                                        result = CurrStepResult == 2 ? 2 : 1,
                                        X = Points[this.CurrPoinntCount].X,
                                        Y = Points[this.CurrPoinntCount].Y,
                                        PointCode = processInfo.ProcessCode,
                                        Data = Math.Round(lstHeight.Average(), 2),
                                        StepName = processName,
                                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        isAverage = true
                                    });
                                    //打印记录
                                    PrintDataList(processName, thicknessParam, CurrProductModel.HeightBaseValue, CurrProductModel.HeightUpFloatValue,
                                        CurrProductModel.HeightDownFloatValue);
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, "厚度读取", lstHeight, Math.Round(lstHeight.Average(), 2),
                                        Math.Round(lstHeight.Max(), 2), Math.Round(lstHeight.Min(), 2), CurrStepResult > 0 ? 3 : 2, false));
                                }
                                else
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, "厚度读取", lstHeight, Math.Round(lstHeight.Average(), 2),
                                        Math.Round(lstHeight.Max(), 2), Math.Round(lstHeight.Min(), 2), 1, false));
                                
                                #endregion
                                break;
                            case "LensMotor":
                                #region 镜头
                                if (confMgr.SysConfigParams.DisableLensMotor)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                LensProp lensParam = JsonConvert.DeserializeObject<LensProp>(jsonParams);
                                //无点位，所以设置为1次执行或0次
                                TestCnt = 0;
                                //判断是否需要使用双控
                                if (!WaitGetStartSig())
                                {
                                    return stepIndex;
                                }
                                //显示当前测试
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, "镜头变焦", new List<double>(),
                                    lensParam.AutoFocus ? 0 : 1, lensParam.AutoMotor ? 0 : 1, lensParam.AutoZPoints ? 0 : 1, 1, false));

                                //开启自动变倍
                                if (lensParam.AutoMotor)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"开始自动变倍,由起始位置{lensMotorDev.GetFeedbackPos(0)}运动到{lensParam.FcousPos}...");
                                    lensMotorDev.MoveAbsPulse(0, new VelocityCurveParams(), (int)lensParam.FcousPos);
                                }
                                else
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"开始手动变倍,由起始位置{lensMotorDev.GetFeedbackPos(0)}运动到{lensParam.MotorPulse}...");
                                    lensMotorDev.MoveAbsPulse(0, new VelocityCurveParams(), lensParam.MotorPulse);
                                }
                                VelocityCurveParams vel_z = new VelocityCurveParams(DefaultSpeed / 2, DefaultSpeed / 2, 0, DefaultSpeed / 2, 1, GetMMtoPlus(AxisName.Axis3));
                                //开启自动对焦
                                if (lensParam.AutoZPoints)
                                {
                                    double zpos = 0;
                                    switch (lensParam.FcousPos)
                                    {
                                        case SmallAxCmdPos.倍率0_58X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_0_58X;
                                            break;
                                        case SmallAxCmdPos.倍率1_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_1_0X;
                                            break;
                                        case SmallAxCmdPos.倍率1_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_1_5X;
                                            break;
                                        case SmallAxCmdPos.倍率2_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_2_0X;
                                            break;
                                        case SmallAxCmdPos.倍率2_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_2_5X;
                                            break;
                                        case SmallAxCmdPos.倍率3_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_3_0X;
                                            break;
                                        case SmallAxCmdPos.倍率3_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_3_5X;
                                            break;
                                        case SmallAxCmdPos.倍率4_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_4_0X;
                                            break;
                                        case SmallAxCmdPos.倍率4_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_4_5X;
                                            break;
                                        case SmallAxCmdPos.倍率5_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_5_0X;
                                            break;
                                        case SmallAxCmdPos.倍率5_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_5_5X;
                                            break;
                                        case SmallAxCmdPos.倍率6_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_6_0X;
                                            break;
                                        case SmallAxCmdPos.倍率6_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_6_5X;
                                            break;
                                        case SmallAxCmdPos.倍率7_0X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_7_0X;
                                            break;
                                        case SmallAxCmdPos.倍率7_5X:
                                            zpos = confMgr.SysConfigParams.LensAxisZPos.Z_7_5X;
                                            break;
                                        default:
                                            zpos = 0;
                                            break;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"开始自动Z轴对焦,运动到{zpos}...");
                                    axisDev.MoveAbsValue(AxisZ, vel_z, zpos);
                                }
                                else
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"开始手动Z轴对焦,运动到{lensParam.ZPoints}...");
                                    axisDev.MoveAbsValue(AxisZ, vel_z, lensParam.ZPoints);
                                }
                                //判断到位
                                lensMotorDev.CheckDone(0, 10000);
                                if (axisDev.CheckDone(AxisZ, 20) != 0)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴Z到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"运动完成，当前镜头位置:{lensMotorDev.GetFeedbackPos(0)}，Z轴位置:{axisDev.GetFeedbackPos(AxisZ)/ GetMMtoPlus(AxisName.Axis3)}");
                                //自动对焦，开启后之后测试启用
                                this.IsAutoFocus = lensParam.AutoFocus;
                                this.FocusStep = lensParam.FocusStep;
                                this.DirStep = lensParam.DirStep;
                                this.DirWaitTime = lensParam.WaitTime;
                                this.FocusTimeOut = lensParam.TimeOut;
                                //显示完成
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, "镜头变焦", new List<double>(), 
                                    lensParam.AutoFocus ? 0 : 1, lensParam.AutoMotor ? 0 : 1, lensParam.AutoZPoints ? 0 : 1, 2, false));
                                #endregion
                                break;
                            case "Light":
                                #region 光源
                                if (confMgr.SysConfigParams.DisableLight)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                //判断是否需要使用双控
                                if (!WaitGetStartSig())
                                {
                                    return stepIndex;
                                }
                                //无点位，所以设置为1次执行或0次
                                TestCnt = 0;
                                LightProp lightParam = JsonConvert.DeserializeObject<LightProp>(jsonParams);
                                //显示当前测试
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, "光源设置", new List<double>(), 0, lightParam.ChannelIndex, lightParam.DigitalValue, 1, false));
                                int nowDiaitalValue = lightDev.GetLightDigitalValue(lightParam.ChannelIndex);
                                Log($"{stepIndex + 1}-{processName}", $"通道{lightParam.ChannelIndex}当前值:{nowDiaitalValue},准备更新值:{lightParam.DigitalValue}...");
                                lightDev.SetLightDigitalValue(lightParam.ChannelIndex, lightParam.DigitalValue);
                                nowDiaitalValue = lightDev.GetLightDigitalValue(lightParam.ChannelIndex);
                                Log($"{stepIndex + 1}-{processName}", $"通道{lightParam.ChannelIndex}更新后当前值:{nowDiaitalValue}。");
                                OnAutoRuning(new RunEventArgs(liStatocStepIndex, "光源设置", new List<double>(), 0, lightParam.ChannelIndex, lightParam.DigitalValue, 2, false));
                                #endregion
                                break;
                            case "Mark":
                                #region Mark
                                
                                MarkProp markParam = JsonConvert.DeserializeObject<MarkProp>(jsonParams);
                                if (((confMgr.SysConfigParams.DisableFrontCam)&&(markParam.MarkType == MarkCam.尺寸检测Mark))||
                                        ((confMgr.SysConfigParams.DisableBackCam) && (markParam.MarkType == MarkCam.缺陷检测Mark)))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                if ((!SizeEnable)&& (markParam.MarkType == MarkCam.尺寸检测Mark))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"尺寸检测功能禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"尺寸检测功能禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                if ((!DefectEnable) && (markParam.MarkType == MarkCam.缺陷检测Mark))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"缺陷检测功能禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"缺陷检测功能禁用，忽略此步骤!", 0, false));
                                    break;
                                }

                                //测试4个mark
                                TestCnt = markParam.MarkCnt;

                                //判断是否需要使用双控
                                if (!WaitGetStartSig())
                                {
                                    return stepIndex;
                                }

                                //获取之后需计算的手选点位
                                //Y轴方向PT值检测
                                //线宽正面
                                //反面检测
                                //X轴方向PT值检测
                                //主栅连接线检测
                                //主栅宽度检测
                                //主栅间距
                                //细栅间距检测
                                //背极宽度
                                
                                List<double> posList = new  List<double>();
                                double[] posArray = null;
                                //string[] pointType = new string[17] { "Y轴方向PT值检测" , "线宽正面" , "反面检测" ,
                                //"X轴方向PT值检测","主栅连接线检测","主栅宽度检测","主栅间距","细栅间距检测","背极宽度",
                                //"主栅长度检测","Mark点横向间距","Mark点竖向间距","鱼叉口长","鱼叉口宽","鱼叉口间距",
                                //"蜈蚣角长", "蜈蚣角宽"};
                                
                                string[] pointType = testLabels.ToArray();
                                int[] adaqter = new int[pointType.Length];

                                if (markParam.AutoMark)
                                {
                                    for (int i = 0; i < pointType.Length; i++)
                                    {
                                        List<TestDefectPoints> t1 = model.TestDefectPointsList.Where(q => q.PointCode == pointType[i]).ToList();
                                        if (t1.Count > 0)
                                        {
                                            if (pointType[i] == "Y轴方向PT值检测" || pointType[i] == "X轴方向PT值检测")
                                                adaqter[i] = t1.Count;
                                            else
                                                adaqter[i] = t1.Count * 2;
                                            //添加点位
                                            for (int j = 0; j < t1.Count; j++)
                                            {
                                                if (t1[j].PointCode == "Y轴方向PT值检测")
                                                    posList.Add(t1[j].X);
                                                else if (t1[j].PointCode == "X轴方向PT值检测")
                                                    posList.Add(t1[j].Y);
                                                else
                                                {
                                                    posList.Add(t1[j].X);
                                                    posList.Add(t1[j].Y);
                                                }
                                            }

                                        }
                                    }
                                }
                                else
                                {
                                    ;
                                }
                                CurrAdaqter = adaqter;
                                if (posList.Count >0)
                                { posArray = posList.ToArray(); }

                                //对应运动轴
                                List<int> AxisIndexList = new List<int>();
                                if (markParam.MarkType == MarkCam.尺寸检测Mark)
                                {
                                    AxisIndexList.Add(AxisX1);
                                    AxisIndexList.Add(AxisY);
                                }
                                else
                                {
                                    AxisIndexList.Add(AxisX2);
                                    AxisIndexList.Add(AxisY);
                                }
                                //图纸判断
                                string typrstr = markParam.MarkType == MarkCam.尺寸检测Mark ? "尺寸检测Mark" : "缺陷检测Mark";
                                attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);
                                Log($"{stepIndex + 1}-{processName}", $"Mark检测,Mark类型:{typrstr},{model.AttachmentList.Count}|{(attachmentFile == null ? "null" : attachmentFile.NameTimestamp + attachmentFile.ExtendName)}");
                                if (attachmentFile != null)
                                {
                                    gbxBmpPath = confMgr.ProjectDir + $"\\{attachmentFile.NameTimestamp}";
                                    if (!File.Exists(gbxBmpPath + attachmentFile.ExtendName))
                                        gbxBmpPath = "";
                                }
                                if (gbxBmpPath == "")
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"Mark检测,Mark类型:{typrstr},图纸不存在！", WarningEnum.High);
                                    return stepIndex;
                                }
                                
                                if (this.CurrPoinntCount == 0)   //第一点开始
                                {
                                    //传图获取Mark位置，图片大小确定是哪个相机
                                    HObject markImg;
                                    string backPath = confMgr.MarkPicPath + (markParam.MarkType == MarkCam.尺寸检测Mark? "\\3333_尺寸.bmp" : "\\3333_缺陷.bmp");
                                    HOperatorSet.ReadImage(out markImg, backPath);
                                    OnAutoRuning(new RunEventArgs(stepIndex, "Mark寻找", new List<double>(), 0, 0, 0, 1, false));
                                    bool isGetMarkPos = GetMarkPoints(true,this.CurrPoinntCount, model.StepInfo.Name, 
                                        stepIndex, processName, markParam.MarkType, markParam.EngineName, markImg.Clone(), gbxBmpPath, adaqter, posArray, false);
                                    if(!isGetMarkPos)
                                    {
                                        //自动获取mark失败
                                        Log($"{stepIndex + 1}-{processName}", $"Mark位置获取等待超时！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                //根据mark寻找trg
                                //判断有无tag
                                if (order.SizeTagDataList == null)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"Mark数据提供者Tag为空！", WarningEnum.High);
                                    return stepIndex;
                                }
                                //tag
                                string MarkTag = "";
                                if (markParam.MarkType == MarkCam.尺寸检测Mark)
                                    MarkTag = "F_Mark_" + stepIndex;
                                else
                                    MarkTag = "B_Mark_" + stepIndex;
                                //用最新的last
                                var sizeTagObj = order.SizeTagDataList.LastOrDefault(m => m.SizeTag == MarkTag);
                                if (sizeTagObj == null)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"未找到自动获取的Mark数据！", WarningEnum.High);
                                    return stepIndex;
                                }
                                string[] posePT = sizeTagObj.posePT.Split(',');
                                if (posePT.Length < this.CurrPoinntCount * 2 + 2)
                                {
                                    Log($"{stepIndex + 1}-{processName}",
                                        $"MarkTag对应消费索引:{this.CurrPoinntCount * 2},Axis数量:{2} 超出postPT:{sizeTagObj.posePT} 范围!", WarningEnum.High);
                                    return stepIndex;
                                }
                                //交换点位顺序1-2-3-4 =》 1-2-4-3
                                string tempPosStr = posePT[4];
                                posePT[4] = posePT[6];
                                posePT[6] = tempPosStr;
                                tempPosStr = posePT[5];
                                posePT[5] = posePT[7];
                                posePT[7] = tempPosStr;
                                //轴运动
                                double[] TagPPUValue = new double[AxisIndexList.Count];
                                for (int i = 0; i < AxisIndexList.Count; i++)
                                    TagPPUValue[i] = double.Parse(posePT[this.CurrPoinntCount * 2 + i]);

                                for (int i = 0; i < TagPPUValue.Length; i++)
                                {
                                    if (axisDev.CheckDone(AxisIndexList[i], 60) != 0)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴{AxisIndexList[i]}到位失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    VelocityCurveParams vel = new VelocityCurveParams(markParam.Acc, markParam.Dec, markParam.VelLow, markParam.VelHigh, MotionST, GetMMtoPlus((AxisName)AxisIndexList[i]));
                                    int iret = 0;
                               
                                    iret = axisDev.MoveAbsValue(AxisIndexList[i], vel, TagPPUValue[i]);
                    
                                    if (iret != 0)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴{AxisIndexList[i]}运动失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                if (sizeTagObj.ConsumeStepIndex == null)
                                    sizeTagObj.ConsumeStepIndex = "";
                                sizeTagObj.ConsumeStepIndex += $"{stepIndex + 1}-{this.CurrPoinntCount}, ";//消费工序ID

                                //多轴同时运行后强制等待各轴完成
                                Log($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

                                if (!WaitAxisDone(AxisIndexList))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"轴组运行完成");
                                Thread.Sleep(markParam.WaitTime);
                                //自动聚焦？
                                if (markParam.MarkType == MarkCam.尺寸检测Mark)
                                {
                                    CamDevFront.SetExposure(markParam.ExposureTime);
                                    CamDevFront.SetGain(markParam.Gain);
                                }
                                if ((this.CurrPoinntCount == 0)&&(IsAutoFocus)&& (markParam.MarkType == MarkCam.尺寸检测Mark))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"自动聚焦...");
                                    if(!AutoFocus(FocusStep, DirStep, DirWaitTime, FocusTimeOut))
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"自动聚焦失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"自动聚焦完成");
                                }
                                //拍照处理
                                HObject DefLastImg = new HObject(); //缺陷左上角使用
                                Log($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");
                                if (markParam.MarkType == MarkCam.尺寸检测Mark)
                                {
                                    //CamDevFront.SetExposure(markParam.ExposureTime);
                                    //CamDevFront.SetGain(markParam.Gain);
                                    Log($"{stepIndex + 1}-{processName}", $"相机参数设置完成。");

                                    DateTime dt0 = DateTime.Now;
                                    CamDevFront.ClearImageQueue();
                                    Acquisition acq0 = CamDevFront.Snap(1, 5000);
                                    if (acq0.GrabStatus != "GrabPass")
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"前部相机采集照片失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"前部相机采集照片完成[" + (DateTime.Now - dt0).Milliseconds.ToString() + "ms]");
                                    //显示
                                    OnAutoRuning(new RunEventArgs(0, acq0.Image));

                                    scannerCBmpQueue.Enqueue(new scannerCBmpLoc(
                                            acq0.Image.Clone(),
                                            GetAxisPosValueMM((int)AxisName.Axis0),
                                            GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue
                                    Log($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，" +
                                        $"X:{GetAxisPosValueMM((int)AxisName.Axis0)},y:{GetAxisPosValueMM((int)AxisName.Axis2)}," +
                                        $"数量: {scannerCBmpQueue.Count}");
                                }
                                else
                                {
                                    CamDevBack.SetExposure(markParam.ExposureTime);
                                    CamDevBack.SetGain(markParam.Gain);

                                    DateTime dt = DateTime.Now;
                                    CamDevBack.ClearImageQueue();
                                    Acquisition acq = CamDevBack.Snap(1, 5000);
                                    if (acq.GrabStatus != "GrabPass")
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"后部相机采集照片失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"后部相机采集照片完成[" + (DateTime.Now - dt).Milliseconds.ToString() + "ms]");
                                    //显示
                                    OnAutoRuning(new RunEventArgs(1, acq.Image));
                                    //----缺陷队列
                                    DefLastImg = acq.Image.Clone();
                                    scannerCBmpQueue.Enqueue(new scannerCBmpLoc(
                                        acq.Image.Clone(),
                                        GetAxisPosValueMM((int)AxisName.Axis1),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue
                                    Log($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，" +
                                        $"X:{GetAxisPosValueMM((int)AxisName.Axis1)},y:{GetAxisPosValueMM((int)AxisName.Axis2)}," +
                                        $"数量: {scannerCBmpQueue.Count}");
                                    
                                }
                                //mark计算
                                bool tRet = GetMarkPoints(false, this.CurrPoinntCount, model.StepInfo.Name,
                                        stepIndex, processName, markParam.MarkType, markParam.EngineName, 
                                        null, gbxBmpPath, adaqter, posArray, (this.CurrPoinntCount + 1) == TestCnt?false:true);
                                if (!tRet)
                                {
                                    //自动获取mark失败
                                    Log($"{stepIndex + 1}-{processName}", $"Mark位置获取等待超时！", WarningEnum.High);
                                    return stepIndex;
                                }
                                //最后判断
                                if((this.CurrPoinntCount + 1) == TestCnt)
                                {
                                    if(markParam.MarkType == MarkCam.缺陷检测Mark)
                                    {
                                        //缺陷获取左上角位置
                                        bool isGetMarkPos = GetMarkPoints(true, this.CurrPoinntCount, model.StepInfo.Name,
                                            stepIndex, processName, markParam.MarkType, markParam.EngineName, DefLastImg.Clone(), gbxBmpPath, adaqter, posArray, false);
                                        if (!isGetMarkPos)
                                        {
                                            //自动获取mark失败
                                            Log($"{stepIndex + 1}-{processName}", $"左上角位置获取等待超时！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                    }
                                    OnAutoRuning(new RunEventArgs(stepIndex, "Mark寻找", new List<double>(), 0, 0, 0, tRet?2:3, false));
                                }
                                #endregion
                                break;
                            case "PointTest":
                                #region 尺寸选点测试
                                PointTestProp testParam = JsonConvert.DeserializeObject<PointTestProp>(jsonParams);
                                if (confMgr.SysConfigParams.DisableFrontCam)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                if (!SizeEnable)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"尺寸检测功能禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"尺寸检测功能禁用，忽略此步骤!", 0, false));
                                    break;
                                }
                                //对应运动轴
                                List<int> PAxisIndexList = new List<int>();
                                PAxisIndexList.Add(AxisX1);
                                PAxisIndexList.Add(AxisY);
                                double[] TestPosTagPPUValue = new double[PAxisIndexList.Count * 2];
                                TestCnt = 0;
                                string[] TestPos = new string[1];

                                //图纸
                                attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);
                                Log($"{stepIndex + 1}-{processName}", $"比对图像,{model.AttachmentList.Count}|{(attachmentFile == null ? "null" : attachmentFile.NameTimestamp + attachmentFile.ExtendName)}");

                                //自动点位数计算
                                if (attachmentFile != null)
                                {
                                    gbxBmpPath = confMgr.ProjectDir + $"\\{attachmentFile.NameTimestamp}";
                                    if (!File.Exists(gbxBmpPath + attachmentFile.ExtendName))
                                        gbxBmpPath = "";
                                }
                                if (gbxBmpPath == "")
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"比对图像,图纸不存在！", WarningEnum.High);
                                    return stepIndex;
                                }

                                if (!testParam.AutoMark)        
                                {
                                    //手动点位数计算
                                    CurrAdaqter = new int[testLabels.Count];
                                    CurrAdaqter[(int)testParam.TestType] = testParam.PointCnt;
                                }
                                //自动寻点
                                if ((testParam.AutoMark)|| (testParam.DefPos))
                                {
                                    //判断有无tag
                                    if (order.SizeTagDataList == null)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"点位数据提供者Tag为空！", WarningEnum.High);
                                        return stepIndex;
                                    }

                                    //tag
                                    string TestPosTag = "F_Pos";
       
                                    //用最新的last
                                    var TestPosTagObj = order.SizeTagDataList.LastOrDefault(m => m.SizeTag == TestPosTag);
                                    if (TestPosTagObj == null)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"未找到自动获取的测试点位数据！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    TestPos = TestPosTagObj.posePT.Split(',');
                                    if ((testParam.DefPos) &&(TestPos.Length < 38))
                                    {
                                        Log($"{stepIndex + 1}-{processName}",
                                            $"自动获取的默认测试点位数据范围错误：{TestPos.Length}!", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                else
                                {
                                    if ((testParam.TestType != PointTestType.线宽正面) && (testParam.TestType != PointTestType.反面检测) 
                                        && (testParam.TestType != PointTestType.背极宽度) && (testParam.TestType != PointTestType.主栅宽度检测
                                        && (testParam.TestType != PointTestType.鱼叉口宽)) && (testParam.TestType != PointTestType.蜈蚣角宽))
                                        TestPos = new string[testParam.Points.Count * 4];
                                    else
                                        TestPos = new string[testParam.Points.Count * 2];
                                    for (int i = 0; i < testParam.Points.Count; i++)
                                    {
                                        TestPos[2 * i] = testParam.Points[i].X.ToString();
                                        TestPos[2 * i + 1] = testParam.Points[i].Y.ToString();
                                    }
                                }
                                int posIndex = this.CurrPoinntCount;
                                //手动顺寻
                                if( (!testParam.SelectPoint)&&(testParam.Indexs.Count >= testParam.PointCnt))
                                {
                                    posIndex = testParam.Indexs[this.CurrPoinntCount];
                                }
                                else if (!testParam.SelectPoint)
                                {
                                    Log($"{stepIndex + 1}-{processName}",
                                            $"手动测试点位顺序范围错误：{testParam.Indexs.Count}!", WarningEnum.High);
                                    return stepIndex;
                                }

                                //判断是否一点完成
                                bool IsOverDef = true;

                                //是否使用点位判断
                                if (testParam.DefPos)
                                {
                                    //使用默认点位测试
                                    if(this.CurrPoinntCount == 0)
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"默认位置检测开始...", null, 0, 0, 0, 1, false));                                   
                                    
                                    switch (testParam.TestType) {
                                        case PointTestType.Y轴方向PT值检测:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            if (testParam.PointCnt > 5 )
                                            {
                                                Log($"{stepIndex + 1}-{processName}", $"Y轴方向PT值检测参数,默认只支持5点以内！", WarningEnum.High);
                                                return stepIndex;
                                            }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[2 * posIndex]); 
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[2 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[2 * posIndex + 10]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[2 * posIndex + 11]);
                                            break;
                                        case PointTestType.线宽正面:
                                            TestCnt = testParam.PointCnt;
                                            if (TestCnt > 9)
                                            {
                                                Log($"{stepIndex + 1}-{processName}", $"线宽正面参数,默认只支持9点以内！", WarningEnum.High);
                                                return stepIndex;
                                            }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[20 + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[20 + 2 * posIndex + 1]);
                                            break;
                                        case PointTestType.反面检测:
                                            Log($"{stepIndex + 1}-{processName}", $"反面检测参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"参数不支持默认!", 4, false));
                                            return stepIndex;
                                        case PointTestType.X轴方向PT值检测:
                                            IsOverDef = false;
                                            Log($"{stepIndex + 1}-{processName}", $"X轴方向PT值检测参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"X轴方向PT值检测参数不支持默认!", 4, false));
                                            return stepIndex;
                                        case PointTestType.主栅连接线检测:
                                            Log($"{stepIndex + 1}-{processName}", $"主栅连接线检测参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"主栅连接线检测参数不支持默认!", 4, false));
                                            return stepIndex;
                                        case PointTestType.主栅宽度检测:
                                            Log($"{stepIndex + 1}-{processName}", $"主栅宽度检测参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"主栅宽度检测参数不支持默认!", 4, false));
                                            return stepIndex;
                                        case PointTestType.主栅间距:
                                            Log($"{stepIndex + 1}-{processName}", $"主栅间距参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"主栅间距参数不支持默认!", 4, false));
                                            return stepIndex;
                                        case PointTestType.细栅间距检测:
                                            Log($"{stepIndex + 1}-{processName}", $"细栅间距检测参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"细栅间距检测参数不支持默认!", 4, false));
                                            return stepIndex;
                                        case PointTestType.背极宽度:
                                            Log($"{stepIndex + 1}-{processName}", $"背极宽度参数不支持默认！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"背极宽度参数不支持默认!", 4, false));
                                            return stepIndex;
                                        default:
                                            Log($"{stepIndex + 1}-{processName}", $"参数不支持！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"参数不支持!", 4, false));
                                            return stepIndex;

                                    }
                                }
                                else
                                {
                                    if (this.CurrPoinntCount == 0)
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"特定位置检测开始...", null, 0, 0, 0, 1, false));
                                    /******************key
                                     * Y轴方向PT值检测
                                        线宽正面
                                        反面检测
                                        X轴方向PT值检测
                                        主栅连接线检测
                                        主栅宽度检测
                                        主栅间距
                                        细栅间距检测
                                        背极宽度
                                     ******************/
                                    List<TestDefectPoints> t = new List<TestDefectPoints>();
                                    switch (testParam.TestType)
                                    {
                                        case PointTestType.Y轴方向PT值检测:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "Y轴方向PT值检测").ToList();
                                            if (testParam.AutoMark)
                                            {
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"Y轴方向PT值检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[2 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[2 * posIndex + this.CurrAdaqter[0] * 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[2 * posIndex + this.CurrAdaqter[0] * 2 + 1]);
                                            break;
                                        case PointTestType.线宽正面:
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "线宽正面").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"线宽正面检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + 2 * posIndex + 1]);
                                            break;
                                        case PointTestType.反面检测:
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "反面检测").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"反面检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] * 2 + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] * 2 + 2 * posIndex + 1]);
                                            break;
                                        case PointTestType.X轴方向PT值检测:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "X轴方向PT值检测").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"X轴方向PT值检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] + this.CurrAdaqter[2] + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] + this.CurrAdaqter[2] + 2 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] + this.CurrAdaqter[2] + 2 * posIndex + this.CurrAdaqter[3] * 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] + this.CurrAdaqter[2] + 2 * posIndex + this.CurrAdaqter[3] * 2 + 1]);
                                            break;
                                        case PointTestType.主栅连接线检测:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "主栅连接线检测").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"主栅连接线检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] 
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] 
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] 
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.主栅宽度检测:
                                            IsOverDef = true;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "主栅宽度检测").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"主栅宽度检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] 
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + 2 * posIndex + 1]);
                                            //TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                            //    + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + 4 * posIndex + 2]);
                                            //TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                            //    + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.主栅间距:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "主栅间距").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"主栅间距检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2]+ this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2]+ this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5] 
                                                + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5] 
                                                + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.细栅间距检测:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "细栅间距检测").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"细栅间距检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.背极宽度:
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "背极宽度").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"背极宽度参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1] 
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + 2 * posIndex + 1]);
                                            break;
                                        case PointTestType.主栅长度检测:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "主栅长度检测").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"主栅长度检测参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + 4 * posIndex 
                                                + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + 4 * posIndex 
                                                + 3]);
                                            break;
                                        case PointTestType.Mark点横向间距:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "Mark点横向间距").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"Mark点横向间距参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.Mark点竖向间距:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "Mark点竖向间距").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"Mark点竖向间距参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.鱼叉口长:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "鱼叉口长").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"鱼叉口长参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5] 
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.鱼叉口宽:
                                            IsOverDef = true;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "鱼叉口宽").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"鱼叉口宽参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + 2 * posIndex + 1]);
                                            //TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                            //    + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                            //    + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                            //    + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + 4 * posIndex + 2]);
                                            //TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                            //    + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                            //    + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                            //    + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.鱼叉口间距:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "鱼叉口间距").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"鱼叉口间距参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.蜈蚣角长:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "蜈蚣角长").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"蜈蚣角长参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.蜈蚣角宽:
                                            IsOverDef = true;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "蜈蚣角宽").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"蜈蚣角宽参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + 2 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + 2 * posIndex + 1]);
                                            break;
                                        case PointTestType.分片间隔:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "分片间隔").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"分片间隔参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.焊点长:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "焊点长").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"焊点长参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17] 
                                                + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.焊点宽:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "焊点宽").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"焊点宽参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.焊点间隔:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "焊点间隔").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"焊点间隔参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + 4 * posIndex + 3]);
                                            break;
                                        case PointTestType.SP2主栅宽度:
                                            IsOverDef = false;
                                            TestCnt = testParam.PointCnt;
                                            t = model.TestDefectPointsList.Where(q => q.PointCode == "SP2主栅宽度").ToList();
                                            if (testParam.AutoMark)
                                                if (testParam.PointCnt > t.Count)
                                                {
                                                    Log($"{stepIndex + 1}-{processName}", $"SP2主栅宽度参数,点数大于产品配置点数！", WarningEnum.High);
                                                    return stepIndex;
                                                }
                                            //走位计算
                                            TestPosTagPPUValue[0] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + this.CurrAdaqter[20] + 4 * posIndex]);
                                            TestPosTagPPUValue[1] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + this.CurrAdaqter[20] + 4 * posIndex + 1]);
                                            TestPosTagPPUValue[2] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + this.CurrAdaqter[20] + 4 * posIndex + 2]);
                                            TestPosTagPPUValue[3] = double.Parse(TestPos[this.CurrAdaqter[0] * 4 + this.CurrAdaqter[1]
                                                + this.CurrAdaqter[2] + this.CurrAdaqter[3] * 4 + this.CurrAdaqter[4] + this.CurrAdaqter[5]
                                                + this.CurrAdaqter[6] + this.CurrAdaqter[7] + this.CurrAdaqter[8] + this.CurrAdaqter[9]
                                                + this.CurrAdaqter[10] + this.CurrAdaqter[11] + this.CurrAdaqter[12] + this.CurrAdaqter[13]
                                                + this.CurrAdaqter[14] + this.CurrAdaqter[15] + this.CurrAdaqter[16] + this.CurrAdaqter[17]
                                                + this.CurrAdaqter[18] + this.CurrAdaqter[19] + this.CurrAdaqter[20] + 4 * posIndex + 3]);
                                            break;
                                        default:
                                            Log($"{stepIndex + 1}-{processName}", $"参数不支持！", WarningEnum.High);
                                            OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"参数不支持!", 4, false));
                                            return stepIndex;

                                    }
                                }
                                //PT检测需要两点
                                for (int i = 0; i < 2; i++)
                                {                                   
                                    //轴运动
                                    for (int j = 0; j < 2; j++)
                                    {
                                        if (axisDev.CheckDone(PAxisIndexList[j], 60) != 0)
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"轴{PAxisIndexList[j]}到位失败！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                        VelocityCurveParams vel = new VelocityCurveParams(testParam.Acc, testParam.Dec, testParam.VelLow, testParam.VelHigh, MotionST, GetMMtoPlus((AxisName)PAxisIndexList[i]));
                                        int iret = 0;

                                        iret = axisDev.MoveAbsValue(PAxisIndexList[j], vel, TestPosTagPPUValue[j  + i *2]);

                                        if (iret != 0)
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"轴{PAxisIndexList[j]}运动失败！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                    }
                                    //多轴同时运行后强制等待各轴完成
                                    Log($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

                                    if (!WaitAxisDone(PAxisIndexList))
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"轴组运行完成");
                                    Thread.Sleep(testParam.WaitTime);

                                    camDevFront.SetExposure(testParam.ExposureTime);
                                    camDevFront.SetGain(testParam.Gain);
                                    //自动聚焦？
                                    if ((this.CurrPoinntCount == 0) && (IsAutoFocus)&& (i == 0))//第一次拍照才聚焦
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"自动聚焦...");
                                        if (!AutoFocus(FocusStep, DirStep, DirWaitTime, FocusTimeOut))
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"自动聚焦失败！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                        Log($"{stepIndex + 1}-{processName}", $"自动聚焦完成");
                                    }
                                    else if (testParam.AutoFocus)//每次都聚焦
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"拍照前自动聚焦...");
                                        if (!AutoFocus(testParam.FocusStep, testParam.DirStep, testParam.WaitDoneTime, testParam.TimeOut))
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"拍照前自动聚焦失败！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                        Log($"{stepIndex + 1}-{processName}", $"拍照前自动聚焦完成");
                                    }
                                    //拍照
                                    Log($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");

                                    DateTime test_dt = DateTime.Now;
                                    camDevFront.ClearImageQueue();
                                    Acquisition test_acq = camDevFront.Snap(1, 5000);
                                    if (test_acq.GrabStatus != "GrabPass")
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"前部相机采集照片失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    Log($"{stepIndex + 1}-{processName}", $"前部相机采集照片完成[" + (DateTime.Now - test_dt).Milliseconds.ToString() + "ms]");
                                    //显示
                                    OnAutoRuning(new RunEventArgs(0, test_acq.Image));

                                    //----处理队列
                                    scannerCBmpQueue.Enqueue(new scannerCBmpLoc(
                                        test_acq.Image.Clone(),
                                        GetAxisPosValueMM((int)AxisName.Axis0),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue
                                    Log($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，" +
                                        $"X:{GetAxisPosValueMM((int)AxisName.Axis0)},y:{GetAxisPosValueMM((int)AxisName.Axis2)}," +
                                        $"数量: {scannerCBmpQueue.Count}");
                                    //处理
                                    if (!PointTestDef(stepIndex, processName, testParam.EngineName, gbxBmpPath, false, model, testParam, IsOverDef))
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"单点测试图像,比对任务失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    //需要二次点位的在循环，否则直接跳出
                                    if (!IsOverDef)
                                        IsOverDef = true;
                                    else
                                        break;
                                }
                                
                                
                                #endregion
                                break;
                            case "SizeAndDefect":
                                #region 缺陷
                                SizeDefectProp defectParam = JsonConvert.DeserializeObject<SizeDefectProp>(jsonParams);
                                if (confMgr.SysConfigParams.DisableBackCam)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"设备禁用，忽略此步骤!", 0, true));
                                    break;
                                }
                                if (!DefectEnable)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"缺陷检测功能禁用，忽略此步骤！");
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"缺陷检测功能禁用，忽略此步骤!", 0, true));
                                    break;
                                }
                                //对应运动轴
                                List<int> DAxisIndexList = new List<int>();
                                DAxisIndexList.Add(AxisX2);
                                DAxisIndexList.Add(AxisY);

                                //OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"比对和缺陷检测开始...", 1, true));
                                //获取首点和长宽
                                if (this.CurrPoinntCount == 0)
                                {
                                    //添加打印信息
                                    AddDefectPrintInfo(defectParam);

                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, "比对和缺陷检测开始...", null, 0, 0, 0, 1, true));
                                    double Pdt_Width = 0;
                                    double Pdt_Height = 0;
                                    //根据mark寻找trg
                                    //判断有无tag
                                    if (order.SizeTagDataList == null)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"Mark数据提供者Tag为空！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    //tag
                                    string LeftPosTag = "B_Pos";
                                    
                                    //用最新的last
                                    var LeftPosTagObj = order.SizeTagDataList.LastOrDefault(m => m.SizeTag == LeftPosTag);
                                    if (LeftPosTagObj == null)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"未找到自动获取的左上角和产品大小数据！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    string[] PosAndSize = LeftPosTagObj.posePT.Split(',');
                                    if (PosAndSize.Length < 6)
                                    {
                                        Log($"{stepIndex + 1}-{processName}",
                                            $"缺陷检测首点对应消费索引:{this.CurrPoinntCount * 2},Axis数量:{2} 超出postPT:{LeftPosTagObj.posePT} 范围!", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    //获取首点，计算步进
                                    //Left_X = double.Parse(PosAndSize[0]) + confMgr.SysConfigParams.DefectCamViewX; //需要偏移
                                    //Left_Y = double.Parse(PosAndSize[1]);
                                    Left_X = double.Parse(PosAndSize[4]); 
                                    Left_Y = double.Parse(PosAndSize[5]);
                                    Pdt_Width = double.Parse(PosAndSize[2]);
                                    Pdt_Height = double.Parse(PosAndSize[3]);

                                    //X_For = (int)(Pdt_Width / confMgr.SysConfigParams.DefectCamViewX) + 1;
                                    //Y_For = (int)(Pdt_Height / confMgr.SysConfigParams.DefectCamViewY) + 1;

                                    //左上角加入视野大小10%的补偿
                                    double temp_dis = confMgr.SysConfigParams.DefectCamViewX * confMgr.SysConfigParams.X_per;
                                    Left_X = double.Parse(PosAndSize[4]) - temp_dis;
                                    temp_dis = confMgr.SysConfigParams.DefectCamViewY * confMgr.SysConfigParams.Y_per;
                                    Left_Y = double.Parse(PosAndSize[5]) + temp_dis;

                                    //double temp_dis = ((X_For * confMgr.SysConfigParams.DefectCamViewX - Pdt_Width) / 2);
                                    //if (temp_dis < (confMgr.SysConfigParams.DefectCamViewX / 5))
                                    //{
                                    //    X_For = X_For + 1;
                                    //    temp_dis = ((X_For * confMgr.SysConfigParams.DefectCamViewX - Pdt_Width) / 2);
                                    //}
                                    //Left_X = double.Parse(PosAndSize[4]) - temp_dis;

                                    //temp_dis = ((Y_For * confMgr.SysConfigParams.DefectCamViewY - Pdt_Height) / 2);
                                    //if (temp_dis < (confMgr.SysConfigParams.DefectCamViewY / 5))
                                    //{
                                    //    Y_For++;
                                    //    temp_dis = ((Y_For * confMgr.SysConfigParams.DefectCamViewY - Pdt_Height) / 2);
                                    //}
                                    //Left_Y = double.Parse(PosAndSize[5]) + temp_dis;

                                    if ((Pdt_Width + (confMgr.SysConfigParams.DefectCamViewX * confMgr.SysConfigParams.X_per)) 
                                        % confMgr.SysConfigParams.DefectCamViewX > 0)
                                        X_For = (int)((Pdt_Width + (confMgr.SysConfigParams.DefectCamViewX * confMgr.SysConfigParams.X_per) )/ confMgr.SysConfigParams.DefectCamViewX) + 1;
                                    else
                                        X_For = (int)((Pdt_Width + (confMgr.SysConfigParams.DefectCamViewX * confMgr.SysConfigParams.X_per)) / confMgr.SysConfigParams.DefectCamViewX);
                                    if ((Pdt_Height + (confMgr.SysConfigParams.DefectCamViewY * confMgr.SysConfigParams.Y_per)) 
                                        % confMgr.SysConfigParams.DefectCamViewY > 0)
                                        Y_For = (int)((Pdt_Height + (confMgr.SysConfigParams.DefectCamViewY * confMgr.SysConfigParams.Y_per)) / confMgr.SysConfigParams.DefectCamViewY) + 1;
                                    else
                                        Y_For = (int)((Pdt_Height + (confMgr.SysConfigParams.DefectCamViewY * confMgr.SysConfigParams.Y_per)) / confMgr.SysConfigParams.DefectCamViewY);

                                    //判断是否使用手动
                                    if(!defectParam.AutoLeft)
                                    {
                                        if (defectParam.LeftPoints.Count > 0)
                                        {
                                            Left_X = defectParam.LeftPoints[0].X;
                                            Left_Y = defectParam.LeftPoints[0].Y;
                                        }
                                        else
                                        {
                                            Log($"{stepIndex + 1}-{processName}", $"设置左上角为空{defectParam.LeftPoints[0]}！", WarningEnum.High);
                                            return stepIndex;
                                        }
                                    }
                                    if (!defectParam.AutoStep)
                                    {
                                        X_For = defectParam.Xstep;
                                        Y_For = defectParam.Ystep;
                                    }

                                    X_For_Index = 0;
                                    Y_For_Index = 0;
                                    ////////////////////
                                    //X_For = 6;
                                    //Y_For = 7;
                                }
                                TestCnt = Y_For * X_For;
                                //走位计算
                                double[] PosTagPPUValue = new double[DAxisIndexList.Count];
                                PosTagPPUValue[0] = Left_X + X_For_Index * confMgr.SysConfigParams.DefectCamViewX;
                                PosTagPPUValue[1] = Left_Y - Y_For_Index * confMgr.SysConfigParams.DefectCamViewY;
                                
                                //轴运动
                                for (int i = 0; i < PosTagPPUValue.Length; i++)
                                {
                                    if (axisDev.CheckDone(DAxisIndexList[i], 60) != 0)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴{DAxisIndexList[i]}到位失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                    VelocityCurveParams vel = new VelocityCurveParams(defectParam.Acc, defectParam.Dec, defectParam.VelLow, defectParam.VelHigh, MotionST, GetMMtoPlus((AxisName)DAxisIndexList[i]));
                                    int iret = 0;

                                    iret = axisDev.MoveAbsValue(DAxisIndexList[i], vel, PosTagPPUValue[i]);

                                    if (iret != 0)
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"轴{DAxisIndexList[i]}运动失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                //if (sizeTagObj.ConsumeStepIndex == null)
                                //    sizeTagObj.ConsumeStepIndex = "";
                                //sizeTagObj.ConsumeStepIndex += $"{stepIndex + 1}-{this.CurrPoinntCount}, ";//消费工序ID

                                //多轴同时运行后强制等待各轴完成
                                Log($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

                                if (!WaitAxisDone(DAxisIndexList))
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"轴到位失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"轴组运行完成");
                                Thread.Sleep(defectParam.WaitTime);
                                //拍照
                                Log($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");
                                
                                CamDevBack.SetExposure(defectParam.ExposureTime);
                                CamDevBack.SetGain(defectParam.Gain);

                                DateTime def_dt = DateTime.Now;
                                CamDevBack.ClearImageQueue();
                                Acquisition def_acq = CamDevBack.Snap(1, 5000);
                                if (def_acq.GrabStatus != "GrabPass")
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"后部相机采集照片失败！", WarningEnum.High);
                                    return stepIndex;
                                }
                                Log($"{stepIndex + 1}-{processName}", $"后部相机采集照片完成[" + (DateTime.Now - def_dt).Milliseconds.ToString() + "ms]");
                                //显示
                                OnAutoRuning(new RunEventArgs(1, def_acq.Image));
                                //图纸
                                attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);
                                Log($"{stepIndex + 1}-{processName}", $"比对图像,{model.AttachmentList.Count}|{(attachmentFile == null ? "null" : attachmentFile.NameTimestamp + attachmentFile.ExtendName)}");
                                if (attachmentFile != null)
                                {
                                    gbxBmpPath = confMgr.ProjectDir + $"\\{attachmentFile.NameTimestamp}";
                                    if (!File.Exists(gbxBmpPath + attachmentFile.ExtendName))
                                        gbxBmpPath = "";
                                }
                                if (gbxBmpPath == "")
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"比对图像,图纸不存在！", WarningEnum.High);
                                    return stepIndex;
                                }
                                //----缺陷队列
                                if (defectParam.OpenDefect)
                                {

                                    var mat = CamDev.HImageToMat(def_acq.Image);
                                    scannerGBmpQueue.Enqueue(new scannerGBmpLoc(mat,
                                        GetAxisPosValueMM((int)AxisName.Axis1),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue 
                                    Log($"{stepIndex + 1}-{processName}", $"缺陷图像队列数量: {scannerGBmpQueue.Count}");
                                    if(!DefectPicture(stepIndex, processName, defectParam, gbxBmpPath, model, model.StepInfo.Name))
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"缺陷处理,缺陷任务失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                if (defectParam.OpenSize)
                                {
                                    scannerCBmpQueue.Enqueue(new scannerCBmpLoc(
                                        def_acq.Image.Clone(),
                                        GetAxisPosValueMM((int)AxisName.Axis1),
                                        GetAxisPosValueMM((int)AxisName.Axis2)));//Dequeue
                                    Log($"{stepIndex + 1}-{processName}", $"比对图像队列，" +
                                        $"X:{GetAxisPosValueMM((int)AxisName.Axis1)},y:{GetAxisPosValueMM((int)AxisName.Axis2)}," +
                                        $"数量: {scannerCBmpQueue.Count}");
                                    //比对处理
                                    
                                    if(!SizeComp(stepIndex, processName, defectParam.EngineName, gbxBmpPath, model.StepInfo.Name, defectParam.AsynRun))
                                    {
                                        Log($"{stepIndex + 1}-{processName}", $"比对图像,比对任务失败！", WarningEnum.High);
                                        return stepIndex;
                                    }
                                }
                                //计算下一步
                                if (Y_For_Index % 2 == 0)
                                {
                                    X_For_Index++;
                                    if (X_For_Index >= X_For)
                                    {
                                        Y_For_Index++;
                                        X_For_Index--;
                                    }
                                }
                                else
                                {
                                    X_For_Index--;
                                    if (X_For_Index < 0)
                                    {
                                        Y_For_Index++;
                                        X_For_Index++;
                                    }
                                }
                                if (Y_For_Index >= Y_For)
                                {
                                    Y_For_Index = 0;
                                    X_For_Index = 0;
                                }
                                #endregion
                                break;
                            case "For":
                                #region 循环
                                long UniqueId = processParam.Value<long>("UniqueId");
                                int GotoStepIndex = processParam.Value<int>("GotoStepIndex");//1-n
                                int LimitNum = processParam.Value<int>("LimitNum");//1-n
                                bool Reset = processParam.Value<bool>("Reset");
                                if (GotoStepIndex - 1 == stepIndex)
                                {
                                    Log($"{stepIndex + 1}-{processName}", $"For死循环！！！", WarningEnum.High);
                                    return stepIndex;
                                }
                                if (!forLib.dicData.ContainsKey(UniqueId))
                                    forLib.dicData.Add(UniqueId, 0);
                                //
                                int Num = forLib.dicData[UniqueId];
                                Num++;
                                if (Num <= LimitNum)
                                {
                                    if (Num == LimitNum)
                                    {
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[{Num}/{LimitNum}]次，循环完成"));
                                        Log($"{stepIndex + 1}-{processName}", $"第[{Num}/{LimitNum}]次，循环完成。");
                                    }
                                    else
                                    {
                                        OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[{Num}/{LimitNum}]次"));
                                        Log($"{stepIndex + 1}-{processName}", $"第[{Num}/{LimitNum}]次跳转到步骤[{GotoStepIndex}]...");
                                        stepIndex = GotoStepIndex - 2;
                                    }
                                    forLib.dicData[UniqueId] = Num;
                                }
                                else
                                {
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"已失效不执行"));
                                    Log($"{stepIndex + 1}-{processName}", $"本循环已失效不执行！");
                                }

                                //达到limit重置0
                                if (forLib.dicData[UniqueId] >= LimitNum && Reset)
                                {
                                    forLib.dicData[UniqueId] = 0;
                                    OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"第[0/{LimitNum}]次"));
                                    Log($"{stepIndex + 1}-{processName}", $"计数器已重置。");
                                }
                                #endregion
                                break;
                            default:
                                Log($"{stepIndex + 1}-{processName}", $"未知新工序：{processInfo.ProcessCode}", WarningEnum.High);
                                return stepIndex;
                        }
                        #endregion
                    }
                }
                else
                {
                    if (IsNewStep)
                    {
                        OnAutoRuning(new RunEventArgs(stepIndex, $"未启用，忽略此步骤!", 0, processInfo.ProcessCode == "SizeAndDefect"));
                    }
                }
                //============结束，判断是否自动下料 
                if (!IsNewStep)
                {
                    #region 老流程结束判断
                    if (stepIndex == processList.Count - 1)
                    {
                        Log("下料", "产品测试完成,移动到下料位");
                        bool ret = GotoLoadPos();
                        if (!ret)
                        {
                            Log("下料", "系统电机复位失败", WarningEnum.High);
                        }

                        if (!RunQG(false))
                        {
                            Log("下料", "系统IO复位失败", WarningEnum.High);
                        }

                        Log("结果", "产品测试完成,等待测试结果...");
                        //等待缺陷图显示完成
                        while (defectBmpNum != defectBmpNumResult)
                            Thread.Sleep(100);

                        //判断是否合格 
                        DefectCodeEnum defectCode;
                        string defectNames = "";                  
                        {
                            #region 结果判断
                            Log("结果", "结果判断");
                            int itemDefectCount;
                            bool isGetQua = false;
                            for (int enumcnt = 0; enumcnt < 14; enumcnt++)
                            {
                                isGetQua = false;
                                //判断是否是过滤项
                                if (model.QualifiedCriterionList != null && model.QualifiedCriterionList.Count > 0)
                                {
                                    foreach (var item in model.QualifiedCriterionList)
                                    {
                                        try
                                        {
                                            defectCode = EnumExtension.Convert2Enum<DefectCodeEnum>(item.DefectCode);
                                            //是过滤
                                            if (defectCode == (DefectCodeEnum)enumcnt)
                                            {
                                                isGetQua = true;
                                                itemDefectCount = getDefectCountFromCode(order, defectCode);
                                                if (item.MaxDefectCount > -1 && itemDefectCount > item.MaxDefectCount)
                                                {
                                                    order.Qualified = false;
                                                    defectNames += $"{EnumExtension.GetEnumDescription(defectCode)}({itemDefectCount}),";
                                                }
                                            }
                                        }
                                        catch { }
                                    }
                                }
                                if (!isGetQua)
                                {
                                    itemDefectCount = getDefectCountFromCode(order, (DefectCodeEnum)enumcnt);
                                    if (itemDefectCount > 0)
                                    {
                                        order.Qualified = false;
                                        defectNames += $"{EnumExtension.GetEnumDescription((DefectCodeEnum)enumcnt)}({itemDefectCount}),";
                                    }
                                }
                            }
                            #endregion
                        }

                        stopWatch.Stop();
                        long timeLen = stopWatch.ElapsedMilliseconds / 1000;
                        OnAutoRuning(new RunEventArgs(4, defectNames == "", AllDefectCount, defectNames));
                        OnAutoRuning(new RunEventArgs(timeLen));
                        //界面显示

                        order.TimeLen = timeLen;
                        order.DefectCount = AllDefectCount;
                        order.Succeed = true;
                        order.ModifyUserCode = order.CreateUserCode = userMgr.LoginUser.Code;

                        order.Abnormalities = "";//无异常
                        order.RepairCode = "";//无修复人员
                                              //如SN检测已存在，先删除
                        var oldSNOrder = OrderService.GetFirst(m => m.SN == order.SN);
                        if (oldSNOrder != null)
                        {
                            Log("删除记录", $"删除上一重复SN检测记录:SN={oldSNOrder.SN}, Date={oldSNOrder.CreateTime}");
                            OrderService.DelNav(oldSNOrder);
                        }
                        if (!OrderService.InsertNav(order))//导航插入
                            Log("保存失败", $"保存生产记录失败！", WarningEnum.Low);

                        //更新本批次检测数量
                        if (!string.IsNullOrWhiteSpace(model.BatchId))
                        {
                            var expOrder = Expressionable.Create<Order>()
                                .And(m => m.ProductId == model.Id)
                                .And(m => m.BatchId == model.BatchId)
                                .ToExpression();//注意 这一句 不能少
                            CurrProductModel.CompleteCount = OrderService.Count(expOrder);
                        }
                        //以主键为条件更新CompleteCount单列值 
                        PdtService.Update(it => new Product() { CompleteCount = CurrProductModel.CompleteCount }, it => it.Id == CurrProductModel.Id);

                        //记录日产量
                        if(confMgr.SetDailyOutputAdd(out DailyOutput))
                        {
                            OnAutoRuning(new RunEventArgs(timeLen, DailyOutput));
                            SendDailyOutput();
                        }

                        Log("完成", $"用时 {order.TimeLen} 秒");
                        _isAuto = false;
                        OnAutoRuning(new RunEventArgs(_isAuto));
                        //GotoReadyPosAndIO();
                        statusMgr.ClearWarning();
                        LedReady();
                        statusMgr.GotoNormalStandby();
                        SendStatus();

                        CurrPoinntCount = 0;
                        CurrProcessIndex = -1;

                        #region MES
                        //MES上传
                        if (confMgr.SysConfigParams.EnableHttp)
                        {
                            string messtr = GetMesString(confMgr.SysConfigParams.HttpTempPath, model, false);
                            Log("MES上传", $"Url:{confMgr.SysConfigParams.HttpUrl}, Date={messtr}");
                            string rel = "";
                            try
                            {
                                rel = HttpApi.Post(confMgr.SysConfigParams.HttpUrl, HttpApi.HttpContentType.application_json, messtr);
                                Log("MES反馈", $"return:{rel}");
                            }
                            catch (Exception e)
                            {
                                Log("MES上传失败", $"失败原因:{e.Message}");
                            }

                            if (!string.IsNullOrEmpty(rel))
                            {
                                try
                                {
                                    JObject jo = (JObject)JsonConvert.DeserializeObject(rel);
                                    if (jo != null)
                                    {
                                        if (jo.ContainsKey(confMgr.SysConfigParams.HttpReturnKey) && jo[confMgr.SysConfigParams.HttpReturnKey] != null)
                                        {
                                            if (jo[confMgr.SysConfigParams.HttpReturnKey].ToString() == confMgr.SysConfigParams.HttpReturnValue)
                                                Log("MES上传", $"上传数据成功：{rel}");
                                            else
                                                Log("MES上传", $"上传数据失败：{rel}", WarningEnum.Low);
                                        }
                                        else
                                            Log("MES上传", $"上传数据无返回结果：{rel}", WarningEnum.Low);
                                    }
                                    else
                                    {
                                        Log("MES上传", $"上传数据无反应：{rel}", WarningEnum.Low);
                                    }
                                }
                                catch (Exception e)
                                {
                                    Log("MES反馈失败", $"失败原因:{e.Message}", WarningEnum.Low);
                                }
                            }
                        }
                        #endregion

                        #region 打印
                        if (confMgr.SysConfigParams.EnableLabelPrint)
                        {
                            Log("标签打印", $"打印机:{confMgr.SysConfigParams.LabelPrinterName}, 模板路径={confMgr.SysConfigParams.LabelTempPath}");
                            ret = PrintFileData(PrinterType.Label, confMgr.SysConfigParams.LabelPrinterName,
                                confMgr.SysConfigParams.LabelTempPath, confMgr.SysConfigParams.LabelData, model);
                            if (ret)
                                Log("标签打印", $"打印成功:{confMgr.SysConfigParams.LabelData}");
                            else
                                Log("标签打印", $"打印失败:打印机={confMgr.SysConfigParams.LabelPrinterName}, 模板路径={confMgr.SysConfigParams.LabelTempPath}, 打印数据={confMgr.SysConfigParams.LabelData}", WarningEnum.Low);
                        }
                        if (confMgr.SysConfigParams.EnableExcelPrint)
                        {
                            Log("Excel打印", $"打印机:{confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={confMgr.SysConfigParams.ExcelTempPath}");
                            ret = PrintFileData(PrinterType.Excel, confMgr.SysConfigParams.ExcelPrinterName,
                                confMgr.SysConfigParams.ExcelTempPath, confMgr.SysConfigParams.ExcelData, model);
                            if (ret)
                                Log("Excel打印", $"打印成功:{confMgr.SysConfigParams.ExcelData}");
                            else
                                Log("Excel打印", $"打印失败:打印机={confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={confMgr.SysConfigParams.ExcelTempPath}, 打印数据={confMgr.SysConfigParams.ExcelData}", WarningEnum.Low);
                        }
                        #endregion
                        return -1;
                    }
                    else //继续
                    {
                        return ++stepIndex;   
                    }
                    #endregion
                }
                else
                {
                    #region 新流程结束判断
                    this.CurrPoinntCount++;
                    if ((stepIndex == processList.Count - 1)&& (this.CurrPoinntCount >= TestCnt))
                    {
                        Log("下料", "产品测试完成,移动到下料位");
                        bool ret = GotoLoadPos();
                        if (!ret)
                        {
                            Log("下料", "系统电机复位失败", WarningEnum.High);
                        }

                        if (!RunQG(false))
                        {
                            Log("下料", "系统IO复位失败", WarningEnum.High);
                        }

                        Log("结果", "产品测试完成,等待测试结果...");
                        //等待比对显示完成
                        while (compBmpNum != compBmpIndex)
                            Thread.Sleep(100);
                        //等待缺陷图显示完成
                        while (defectBmpNum != defectBmpNumResult)
                            Thread.Sleep(100);

                        //判断是否合格 
                        DefectCodeEnum defectCode;
                        string defectNames = "";
                        if (model.QualifiedCriterionList != null && model.QualifiedCriterionList.Count > 0)
                        {
                            int itemDefectCount;
                            foreach (var item in model.QualifiedCriterionList)
                            {
                                try
                                {
                                    defectCode = EnumExtension.Convert2Enum<DefectCodeEnum>(item.DefectCode);
                                    itemDefectCount = getDefectCountFromCode(order, defectCode);
                                    if (item.MaxDefectCount > -1 && itemDefectCount > item.MaxDefectCount)
                                    {
                                        order.Qualified = false;
                                        defectNames += $"{EnumExtension.GetEnumDescription(defectCode)}({itemDefectCount}),";
                                    }
                                }
                                catch
                                { }
                            }
                        }
                        else
                        {
                            Log("结果", "默认判断");
                            int itemDefectCount;
                            for (int enumcnt = 0; enumcnt < 14; enumcnt++)
                            {
                                try
                                {
                                    itemDefectCount = getDefectCountFromCode(order, (DefectCodeEnum)enumcnt);
                                    if (itemDefectCount > 0)
                                    {
                                        order.Qualified = false;
                                        defectNames += $"{EnumExtension.GetEnumDescription((DefectCodeEnum)enumcnt)}({itemDefectCount}),";
                                    }
                                }
                                catch
                                { }
                            }
                        }
                        //移除最后的，
                        if(defectNames.Length>0)
                        {
                            defectNames = defectNames.Remove(defectNames.Length - 1);
                        }
                        stopWatch.Stop();
                        long timeLen = stopWatch.ElapsedMilliseconds / 1000;
                        //OnAutoRuning(new RunEventArgs(4, defectNames == "", AllDefectCount, defectNames));
                        OnAutoRuning(new RunEventArgs(stepIndex, $"缺陷检测全部完成：{defectNames}",
                            new List<double>(), 1, 0, AllDefectCount, defectNames == ""?2:3, true));
                        OnAutoRuning(new RunEventArgs(timeLen));
                        //界面显示

                        order.TimeLen = timeLen;
                        order.DefectCount = AllDefectCount;
                        order.Succeed = true;
                        order.ModifyUserCode = order.CreateUserCode = userMgr.LoginUser.Code;

                        order.Abnormalities = "";//无异常
                        order.RepairCode = "";//无修复人员
                                              //如SN检测已存在，先删除
                        var oldSNOrder = OrderService.GetFirst(m => m.SN == order.SN);
                        if (oldSNOrder != null)
                        {
                            Log("删除记录", $"删除上一重复SN检测记录:SN={oldSNOrder.SN}, Date={oldSNOrder.CreateTime}");
                            OrderService.DelNav(oldSNOrder);
                        }
                        if (!OrderService.InsertNav(order))//导航插入
                            Log("保存失败", $"保存生产记录失败！", WarningEnum.Low);

                        //更新本批次检测数量
                        if (!string.IsNullOrWhiteSpace(model.BatchId))
                        {
                            var expOrder = Expressionable.Create<Order>()
                                .And(m => m.ProductId == model.Id)
                                .And(m => m.BatchId == model.BatchId)
                                .ToExpression();//注意 这一句 不能少
                            CurrProductModel.CompleteCount = OrderService.Count(expOrder);
                        }
                        //以主键为条件更新CompleteCount单列值 
                        PdtService.Update(it => new Product() { CompleteCount = CurrProductModel.CompleteCount }, it => it.Id == CurrProductModel.Id);

                        //记录日产量
                        if (confMgr.SetDailyOutputAdd(out DailyOutput))
                        {
                            OnAutoRuning(new RunEventArgs(timeLen, DailyOutput));
                            SendDailyOutput();
                        }

                        Log("完成", $"用时 {order.TimeLen} 秒");
                        _isAuto = false;
                        OnAutoRuning(new RunEventArgs(_isAuto));
                        //GotoReadyPosAndIO();
                        statusMgr.ClearWarning();
                        LedReady();
                        statusMgr.GotoNormalStandby();
                        SendStatus();

                        CurrStepResult = 0;
                        CurrPoinntCount = 0;
                        CurrProcessIndex = -1;

                        #region MES
                        //MES上传
                        if (confMgr.SysConfigParams.EnableHttp)
                        {
                            string messtr = GetMesString(confMgr.SysConfigParams.HttpTempPath, model, true);
                            Log("MES上传", $"Url:{confMgr.SysConfigParams.HttpUrl}, Date={messtr}");
                            string rel = "";
                            try
                            {                               
                                rel = HttpApi.Post(confMgr.SysConfigParams.HttpUrl, HttpApi.HttpContentType.application_json, messtr);
                                Log("MES反馈", $"return:{rel}");
                            }
                            catch (Exception e)
                            {
                                Log("MES上传失败", $"失败原因:{e.Message}");
                            }

                            if (!string.IsNullOrEmpty(rel))
                            {
                                try
                                {
                                    JObject jo = (JObject)JsonConvert.DeserializeObject(rel);
                                    if (jo != null)
                                    {
                                        if (jo.ContainsKey(confMgr.SysConfigParams.HttpReturnKey) && jo[confMgr.SysConfigParams.HttpReturnKey] != null)
                                        {
                                            if(jo[confMgr.SysConfigParams.HttpReturnKey].ToString() == confMgr.SysConfigParams.HttpReturnValue)
                                                Log("MES上传", $"上传数据成功：{rel}");
                                            else
                                                Log("MES上传", $"上传数据失败：{rel}", WarningEnum.Low);        
                                        }
                                        else
                                            Log("MES上传", $"上传数据无返回结果：{rel}", WarningEnum.Low);
                                    }
                                    else
                                    {
                                        Log("MES上传", $"上传数据无反应：{rel}", WarningEnum.Low);
                                    }
                                }
                                catch (Exception e)
                                {
                                    Log("MES反馈失败", $"失败原因:{e.Message}", WarningEnum.Low);
                                }
                            }
                        }
                        #endregion

                        #region 打印
                        if (model.EnableLabelPrint)
                        {
                            Log("标签打印", $"打印机:{confMgr.SysConfigParams.LabelPrinterName}, 模板路径={model.LabelTempPath}");
                            ret = PrintFileData(PrinterType.Label, confMgr.SysConfigParams.LabelPrinterName,
                                model.LabelTempPath, CurrPrintInfos, model);
                            if(ret)
                                Log("标签打印", $"打印成功:{CurrPrintInfos}");
                            else
                                Log("标签打印", $"打印失败:打印机={confMgr.SysConfigParams.LabelPrinterName}, 模板路径={model.LabelTempPath}, 打印数据={CurrPrintInfos}", WarningEnum.Low);
                        }
                        if (model.EnableExcelPrint)
                        {
                            Log("Excel打印", $"打印机:{confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={model.ExcelTempPath}");
                            ret = PrintFileData(PrinterType.Excel, confMgr.SysConfigParams.ExcelPrinterName,
                                model.ExcelTempPath, CurrPrintInfos, model);
                            if (ret)
                                Log("Excel打印", $"打印成功:{CurrPrintInfos}");
                            else
                                Log("Excel打印", $"打印失败:打印机={confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={model.ExcelTempPath}, 打印数据={CurrPrintInfos}", WarningEnum.Low);
                        }
                        //获取当前工单
                        CurrDefectOrders = OrderService.GetListNav(order.DetectOrder);
                        if (model.EnableOrderPrint && (CurrDefectOrders.Count == TotalCnt))
                        {
                            DialogResult result = MessageBox.Show($"工单检测完成,数量{CurrDefectOrders.Count},是否打印?", "检验工单打印",
                                MessageBoxButtons.YesNo);
                            if (result == DialogResult.Yes)
                            {
                                Log("工单打印", $"打印机:{confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={model.OrderTempPath}");

                                ret = PrintFileOrderData(confMgr.SysConfigParams.ExcelPrinterName,
                                    model.OrderTempPath, CurrOrderPrintInfos, model);
                                if (ret)
                                    Log("工单打印", $"打印成功！");
                                else
                                    Log("工单打印", $"打印失败:打印机={confMgr.SysConfigParams.ExcelPrinterName}, 模板路径={model.OrderTempPath}, 打印数据={CurrOrderPrintInfos}", WarningEnum.Low);
                            }
                        }
                        #endregion
                        return -1;
                    }
                    else //继续
                    { 
                        if (this.CurrPoinntCount >= TestCnt )
                        {
                            CurrStepResult = 0;
                            this.CurrPoinntCount = 0;
                            lstTestData.Clear();
                            //新流程需要判断是否跑完该流程所有点位
                            return ++stepIndex;
                        }
                        else
                            return stepIndex;   
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            {
                Log("工序", $"[{stepIndex + 1}] Err:" + ex.Message + "\n" + ex.StackTrace, WarningEnum.High);
                return -2;
            }
        }

        #region 缺陷数量
        /// <summary>
        /// 根据缺陷code获取缺陷数量
        /// </summary>
        /// <param name="order"></param>
        /// <param name="defectCodeEnum"></param>
        /// <returns></returns>
        private int getDefectCountFromCode(Order order, DefectCodeEnum defectCodeEnum)
        {
            switch (defectCodeEnum)
            {
                case DefectCodeEnum.dk:
                    return order.DKCount;
                case DefectCodeEnum.zw:
                    return order.ZWCount;
                case DefectCodeEnum.gsyc:
                    return order.GSYCCount;
                case DefectCodeEnum.xws:
                    return order.XWSCount;
                case DefectCodeEnum.qk:
                    return order.QKCount;
                case DefectCodeEnum.zk:
                    return order.ZKCount;
                case DefectCodeEnum.pp:
                    return order.PPCount;
                case DefectCodeEnum.hs:
                    return order.HSCount;
                case DefectCodeEnum.yx:
                    return order.YXCount;
                case DefectCodeEnum.xb:
                    return order.XBCount;
                case DefectCodeEnum.sx:
                    return order.SXCount;
                case DefectCodeEnum.ds:
                    return order.DSCount;
                //case DefectCodeEnum.gsdl:
                //    return order.GSDLCount;
                //case DefectCodeEnum.cjdk:
                //    return order.CJDKCount;
                default:
                    return 0;
            }
        }
        #endregion

        #region 厚度检测
        /// <summary>
        /// 厚度检测
        /// </summary>
        /// <param name="stepIndex"></param>
        /// <param name="param"></param>
        /// <param name="isBase"></param>
        /// <returns></returns>
        private int HeightProcessTest(int stepIndex, string processName, string param, bool isBase)
        {
            int ret = 0;
            if (!WaitAllAxisDone())//因启用轴异步功能,使用前需等待
            {
                Log($"厚度基准测量", $"轴到位失败！", WarningEnum.High);
                return stepIndex;
            }
            

            //判断是否有产品
            bool sts;
            if(isBase) //打基准
            {
                ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.产品有无), GetIOBitIndex((int)DIName.产品有无), out sts);
                if(sts)
                {
                    Log($"厚度基准测量", $"存在产品,请下料,并重新开始！", WarningEnum.High);
                    return -1;
                }
                //开启线程自动打基准
                Thread t = new System.Threading.Thread(()=>RunGetHeightValue(stepIndex, processName, param, isBase));
                t.IsBackground = true;
                t.Start();
            }
            return ret;
        }

        private void RunGetHeightValue(int stepIndex, string processName, string param, bool isBase)
        {
            int AxisX = (int)AxisName.Axis0;
            int AxisY = (int)AxisName.Axis2;
            List<int> axislist = new List<int>() { AxisX, AxisY };
            JObject processParam = JObject.Parse(param);
            int TestCnt = processParam.Value<int>("TestCnt");
            DataProcess dataProcess = (DataProcess)processParam.Value<int>("ProcessData");
            int DelayTime = processParam.Value<int>("DelayTime");
            int DataCnt = processParam.Value<int>("DataCnt");
            double OffsetValue = processParam.Value<double>("OffsetValue");
            //List<PointF> Points = processParam.Value<List<PointF>>("Points");
            ThicknessProp thicknessParam = JsonConvert.DeserializeObject<ThicknessProp>(param);
            List<PointF> Points = thicknessParam.Points;

            double VelLow = processParam.Value<double>("VelLow");
            double VelHigh = processParam.Value<double>("VelHigh");
            double Acc = processParam.Value<double>("Acc");
            double Dec = processParam.Value<double>("Dec");
            int WaitTime = processParam.Value<int>("WaitTime");

            //开始循环测试
            //打基准
            if(isBase)
            {
                Log($"厚度基准值-{processName}", processParam.ToString());
                if(TestCnt > Points.Count)
                {
                    Log($"厚度基准值-{processName}", $"点位少于测试次数！", WarningEnum.High);
                    return;
                }
                for (int i = 0; i < Points.Count; i++)
                {
                    Log($"厚度基准值-{processName}", $"点位{i+1}测试");
                    Log($"厚度基准值-{processName}",
                        $"XY准备(绝对)运动至{Points[i].X},{Points[i].Y}...");

                    if (axisDev.CheckDone(AxisX, 20) != 0)
                    {
                        Log($"厚度基准值-{processName}", $"轴X1到位失败！", WarningEnum.High);
                        return;
                    }
                    if (axisDev.CheckDone(AxisY, 20) != 0)
                    {
                        Log($"厚度基准值-{processName}", $"轴Y到位失败！", WarningEnum.High);
                        return;
                    }
                    VelocityCurveParams velx = new VelocityCurveParams(Acc, Dec, VelLow, VelHigh, MotionST, GetMMtoPlus((AxisName)AxisX));
                    VelocityCurveParams vely = new VelocityCurveParams(Acc, Dec, VelLow, VelHigh, MotionST, GetMMtoPlus((AxisName)AxisY));
                    int iret1 = 0;
                    int iret2 = 0;
                    iret1 = axisDev.MoveAbsValue(AxisX, velx, Points[i].X);
                    iret2 = axisDev.MoveAbsValue(AxisY, vely, Points[i].Y);
                    if (iret1 != 0)
                    {
                        Log($"厚度基准值-{processName}", $"轴X1运动失败！", WarningEnum.High);
                        return;
                    }
                    if (iret2 != 0)
                    {
                        Log($"厚度基准值-{processName}", $"轴Y运动失败！", WarningEnum.High);
                        return;
                    }
                    //多轴同时运行后强制等待各轴完成
                    Log($"厚度基准值-{processName}", $"等待轴组运行完成...");
                    if (!WaitAxisDone(axislist))
                    {
                        Log($"厚度基准值-{processName}", $"轴到位失败！", WarningEnum.High);
                        return;
                    }
                    Thread.Sleep(WaitTime);
                    Log($"厚度基准值-{processName}", $"轴组运行完成");
                    //测厚气缸下降
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), true);
                    Thread.Sleep(confMgr.HeightDoWait);
                    //读取数据
                    double TempVal = 0;
                    List<double> tempDataList = new List<double>();
                    for (int j = 0; j < DataCnt; j++)
                    {
                        Thread.Sleep(DelayTime);
                        TempVal = thicknessDev.GetValue();
                        if (TempVal < 0)
                        {
                            Log("厚度读取", "厚度读取失败，忽略此次测试!");
                            return;
                        }
                        tempDataList.Add(TempVal);
                    }
                    switch (dataProcess)
                    {
                        case DataProcess.均值:
                            TempVal = tempDataList.Average();
                            break;
                        case DataProcess.最大值:
                            TempVal = tempDataList.Max();
                            break;
                        case DataProcess.最小值:
                            TempVal = tempDataList.Min();
                            break;
                        default:
                            TempVal = tempDataList.Average();
                            Log("厚度读取", "厚度读取处理错误,启用均值!");
                            break;
                    }
                    TempVal = Math.Round(TempVal, 2);
                    Log("厚度读取", $"厚度值基准值{i+1}:{TempVal}");
                    lstHeightBase.Add(TempVal);
                    //测厚气缸上升
                    ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.测厚气缸), GetIOBitIndex((int)DOName.测厚气缸), false);
                    Thread.Sleep(confMgr.HeightDoWait);
                }
            }
            GotoLoadPos();
            //打开加紧气缸
            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.加紧气缸), GetIOBitIndex((int)DOName.加紧气缸), false);
            IsCurrHeightBase = true;
            Log("厚度读取", $"获取基准值完毕！");
        }
        #endregion

        #region 双控
        /// <summary>
        /// 等待双控按钮按下
        /// </summary>
        /// <returns></returns>
        private bool WaitGetStartSig()
        {
            bool ret = false;
            bool sts;
            if (!IsGetStartSig)
            {
                GotoLoadPos();
                ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), true);
                Log($"双控启动", $"等待双控按下....");
                while (true)
                {
                    if (isBreakProcessRun())
                    {
                        ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
                        return false;
                    }
                    ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.双手启动), GetIOBitIndex((int)DIName.双手启动), out sts);
                    if (sts)
                    {
                        if (confMgr.SysConfigParams.OpenPdtIsHave)
                            ioCardDev.GetDIBitState(GetIOPortIndex((int)DIName.产品有无), GetIOBitIndex((int)DIName.产品有无), out sts);
                        else
                            sts = true;
                        if (sts)
                        {
                            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.加紧气缸), GetIOBitIndex((int)DOName.加紧气缸), true);
                            Thread.Sleep(confMgr.ProductDoWait);
                            Log($"双控启动", $"双控按钮按下启动");
                            IsGetStartSig = true;

                            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
                            return true;
                        }
                        else
                        {
                            Log($"双控启动", $"无产品信号");
                            ioCardDev.WriteBitState(GetIOPortIndex((int)DOName.双手启动绿灯), GetIOBitIndex((int)DOName.双手启动绿灯), false);
                            IsGetStartSig = false;
                            return false;
                        }
                    }
                    Thread.Sleep(100);
                }
            }
            else
                return true;
            //return ret;
        }
        #endregion

        #region Mark
        /// <summary>
        /// 自动获取mark位置
        /// </summary>
        /// <param name="StepIndex"></param>
        /// <param name="ProcessName"></param>
        /// <param name="EngineName"></param>
        /// <param name="img"></param>
        /// <param name="gbxBmpPath"></param>
        /// <param name="getPosArray"></param>
        /// <param name="asynRun"></param>
        private bool GetMarkPoints(bool IsMarkPic, int pointIndex, string picName,int StepIndex, string ProcessName, MarkCam marktype,string EngineName, HObject img, string gbxBmpPath, int[] adapter,double[] getPosArray, bool asynRun)
        {
            //HOperatorSet.WriteImage(img, "bmp", 0, "123.bmp");
            if(adapter == null || adapter.Length == 0)
            {
                adapter = new int[9] { 5, 18 ,0,0,0,0,0,0,0};
            }
            else if(adapter.Max() == 0)
                adapter = new int[9] { 5, 18, 0, 0, 0, 0, 0, 0, 0 };

            if (getPosArray == null || getPosArray.Length == 0)
            {
                getPosArray = new double[23];
            }
            int typeIndex = 0;
            scannerCBmpLoc bmpCBmpQueue = new scannerCBmpLoc("",1,2);
            //判断是否是第一次寻找mark
            if (IsMarkPic)
                typeIndex = 3333;
            else
            {
                bmpCBmpQueue = scannerCBmpQueue.Dequeue();
                if (pointIndex == 0)
                    typeIndex = marktype == MarkCam.尺寸检测Mark ? 1111 : 111;
                else if (pointIndex == 1)
                    typeIndex = marktype == MarkCam.尺寸检测Mark ? 2222 : 222;
                else if (pointIndex == 2)
                    typeIndex = marktype == MarkCam.尺寸检测Mark ? 4444 : 444;
                else if (pointIndex == 3)
                    typeIndex = marktype == MarkCam.尺寸检测Mark ? 3333 : 333;
            }
            //tag
            string MarkTag = "";
            if (IsMarkPic)
            {
                if (marktype == MarkCam.尺寸检测Mark)
                    MarkTag = "F_Mark_" + StepIndex;
                else
                {
                    if (pointIndex == 3)
                        MarkTag = "B_Pos";
                    else
                        MarkTag = "B_Mark_" + StepIndex;
                }
            }
            else
            {
                if (marktype == MarkCam.尺寸检测Mark)
                    MarkTag = "F_Pos";
                else
                    MarkTag = "B_Pos";
            }
            //需要偏移校正，index=0时不能异步 //10,20,30...　
            AutoResetEvent endEvent = new AutoResetEvent(false);
            SizeLib.add(new SizeTask()
            {
                stepIndex = StepIndex,
                processName = ProcessName,
                engineName = EngineName,

                drawingPagePath = gbxBmpPath,

                Himage = IsMarkPic? img.Clone() : bmpCBmpQueue.Himage.Clone(),//bmp/file_path二选一，优先bmp
                file_path = bmpCBmpQueue.Path,
                posX = bmpCBmpQueue.PosX,
                posY = bmpCBmpQueue.PosY,

                sizeTag = MarkTag,
                //2023-10-27
                Adapter = adapter,
                AdapterPos = getPosArray,
                index = typeIndex,//Mark
                ContoursAffineTrans1_Out = this.contoursAffineTrans1_Out,//只有777时才使用最近333输出的结果 
                finishEvent = (res) =>
                {
                    try
                    {
                        if (res.index == 111 || res.index == 222 || res.index == 333 || res.index == 444)
                        {
                            Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找缺陷Mark点 Index={res.index}，结果记录...");
                            if (res.index == 333) this.contoursAffineTrans1_Out = res.ContoursAffineTrans1_Out;//不管成功失败都替换
                            if (res.isSucceed)
                            {
                                Thread.Sleep(100);
                                Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找缺陷Mark点 Index={res.index}; 当前值：{string.Join(",", res.MarkPointList)}");
                                JArray markDatas;
                                if (string.IsNullOrWhiteSpace(order.MarkData))
                                    markDatas = new JArray() { 0, 0, 0, 0, 0, 0, 0, 0 };
                                else
                                    markDatas = JArray.Parse(order.MarkData);
                                for (int i = 0; i < res.MarkPointList.Count(); i++)
                                    if (res.MarkPointList[i] != 0)
                                        markDatas[i] = res.MarkPointList[i];
                                order.MarkData = markDatas.ToString();
                                //OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}，Mark点:{order.MarkData} "));
                                Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找缺陷Mark点 Index={res.index};合并后：{order.MarkData}");
                            }
                            else
                            {
                                OnAutoRuning(new RunEventArgs(res.stepIndex, "Mark寻找", new List<double>(), 0, 0, 0, 3, false));
                                Log($"{res.stepIndex + 1}-{res.processName}", $"Mark点计算失败，index:{res.index}.", confMgr.SysConfigParams.OpenMarkErrorStop ? WarningEnum.High : WarningEnum.Normal);

                            }

                            //保存
                            if (confMgr.SysConfigParams.SizeBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeBigImag.SavePath))
                            {
                                string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{picName}.bmp";
                                if (res.Himage != null)
                                    HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                                else
                                    API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                            }
                        }
                        else
                        {
                            int roundIndex = res.index % 10;
                            if (res.isSucceed)
                            {
                                string tagOutData = "";
                                if (res.index == 3333 && !string.IsNullOrWhiteSpace(res.sizeTag))
                                {
                                    tagOutData = $"自动寻找尺寸Mark点位:[{string.Join(",", res.posePT)}]";
                                    if (res.posePT.Length < 2 || res.posePT.Length % 2 != 0)
                                    {
                                        Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找尺寸Mark出错: {tagOutData}", WarningEnum.High);
                                        return;
                                    }
                                    //2023-10-27
                                    Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找尺寸Mark对应Adapter: {string.Join(",", res.Adapter)}", WarningEnum.Normal);
                                    Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找尺寸Mark对应AdapterPos: {string.Join(",", res.AdapterPos)}", WarningEnum.Normal);
                                    Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找尺寸Mark对应posePT: {tagOutData}", WarningEnum.Normal);

                                    if (order.SizeTagDataList == null)
                                        order.SizeTagDataList = new List<SizeTagData>();
                                    order.SizeTagDataList.Add(new SizeTagData()
                                    {
                                        SizeTag = res.sizeTag,
                                        CreateStepIndex = res.stepIndex + 1,
                                        posePT = string.Join(",", res.posePT)// 回转 Array.ConvertAll(sNums , double.Parse);
                                    });

                                }
                                //OnAutoRuning(new RunEventArgs(liStatocStepIndex,
                                //    $"index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData}"));
                                //Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测完成 index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData} ");

                            }
                            //失败
                            else
                            {
                                OnAutoRuning(new RunEventArgs(res.stepIndex, "Mark寻找", new List<double>(), 0, 0, 0, 3, false));
                                Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找尺寸Mark对应Adapter: {string.Join(",", res.Adapter)}", WarningEnum.Normal);
                                Log($"{res.stepIndex + 1}-{res.processName}", $"自动寻找尺寸Mark对应AdapterPos: {string.Join(",", res.AdapterPos)}", WarningEnum.Normal);
                                Log($"{res.stepIndex + 1}-{res.processName}", $"Mark点计算失败，index:{res.index}.", confMgr.SysConfigParams.OpenMarkErrorStop ? WarningEnum.High : WarningEnum.Normal);

                            }

                            //保存
                            if (confMgr.SysConfigParams.SizeBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeBigImag.SavePath))
                            {
                                string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{picName}.bmp";
                                if (res.Himage != null)
                                    HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                                else
                                    API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                            }
                        }                                           
                    }
                    catch (Exception ex)
                    {
                        Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测回调处理异常 index:{res.index}，ex={ex.Message}");
                    }
                    endEvent.Set();//roundIndex＝０成功或失败线程返回
                                   //---
                    if (res.Himage != null)
                    {
                        res.Himage.Dispose();
                        res.Himage = null;
                    }
                    
                }
            });

            //需等上面异步回调中的相对偏移校正完成再继续
            if (!asynRun)
            {
                if (!endEvent.WaitOne(10000))
                {
                    Log($"{StepIndex + 1}-{ProcessName}", $"Mark位置获取等待超时，忽略继续！", WarningEnum.Low);
                    return false;
                }
            }
            return true;
        }


        #endregion

        #region PT线宽等处理
        /// <summary>
        /// 获取上下限
        /// </summary>
        /// <param name="index"></param>
        /// <param name="data"></param>
        /// <param name="aveData"></param>
        /// <param name="model"></param>
        /// <param name="testParam"></param>
        /// <param name="Max"></param>
        /// <param name="Min"></param>
        /// <param name="TestName"></param>
        private void GetLimitInfo(int index, double data, double aveData, Product model, PointTestProp testParam,
            out double Max, out double Min, out string TestName )
        {
            double PtUpper = 0;
            double PtLower = 0;
            string testName = "";
            //上下限设置
            switch (index)
            {
                #region 单点
                case 8001:
                    Log($"线宽值", $"线宽{lstTestData.Count}:{data}");
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.LineWidthBaseValue + model.LineWidthUpFloatValue;
                        PtLower = model.LineWidthBaseValue - model.LineWidthDownFloatValue;
                    }
                    if (order != null)
                        order.LineWidthValue = aveData;
                    testName = "线宽正面";
                    break;
                case 8002:
                    Log($"反面检测值", $"反面检测{lstTestData.Count}:{data}");
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.FLineWidthBaseValue + model.FLineWidthUpFloatValue;
                        PtLower = model.FLineWidthBaseValue - model.FLineWidthDownFloatValue;
                    }
                    if (order != null)
                        order.FLineWidthValue = aveData;
                    testName = "反面检测";
                    break;
                case 8007:
                    Log($"背极宽度值", $"背极宽度{lstTestData.Count}:{data}");
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.BackPoleWidthBaseValue + model.BackPoleWidthUpFloatValue;
                        PtLower = model.BackPoleWidthBaseValue - model.BackPoleWidthDownFloatValue;
                    }
                    if (order != null)
                        order.BackPoleWidthValue = aveData;
                    testName = "背极宽度";
                    break;
                case 8003:
                    Log($"鱼叉口宽值", $"鱼叉口宽{lstTestData.Count}:{data}");
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.ForkWidthBaseValue + model.ForkWidthUpFloatValue;
                        PtLower = model.ForkWidthBaseValue - model.ForkWidthDownFloatValue;
                    }
                    if (order != null)
                        order.ForkWidthValue = aveData;
                    testName = "鱼叉口宽";
                    break;
                case 8004:
                    Log($"蜈蚣角宽值", $"蜈蚣角宽{lstTestData.Count}:{data}");
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.ChilopodWidthBaseValue + model.ChilopodWidthUpFloatValue;
                        PtLower = model.ChilopodWidthBaseValue - model.ChilopodWidthDownFloatValue;
                    }
                    if (order != null)
                        order.ChilopodWidthValue = aveData;
                    testName = "蜈蚣角宽";
                    break;
                case 8005:
                    Log($"主栅宽度检测值", $"主栅宽度检测{lstTestData.Count}:{data}");
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MGridWidthBaseValue + model.MGridWidthUpFloatValue;
                        PtLower = model.MGridWidthBaseValue - model.MGridWidthDownFloatValue;
                    }
                    if (order != null)
                        order.MGridWidthValue = aveData;
                    testName = "主栅宽度检测";
                    break;
                #endregion
                #region 双点
                case 8102:
                    Log($"Y-PT值", $"PT{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.PTValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.PTBaseValue + model.PTUpFloatValue;
                        PtLower = model.PTBaseValue - model.PTDownFloatValue;
                    }
                    testName = "Y轴方向PT值检测";
                    break;
                case 8202:
                    Log($"X-PT值", $"PT{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.XPTValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.PTXBaseValue + model.PTXUpFloatValue;
                        PtLower = model.PTXBaseValue - model.PTXDownFloatValue;
                    }
                    testName = "X轴方向PT值检测";
                    break;
                case 8302:
                    Log($"主栅连接线检测值", $"主栅连接线检测{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.MGridIntervalValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MGridIntervalBaseValue + model.MGridIntervalUpFloatValue;
                        PtLower = model.MGridIntervalBaseValue - model.MGridIntervalDownFloatValue;
                    }
                    testName = "主栅连接线检测";
                    break;
                case 8402:
                    Log($"主栅宽度检测值", $"主栅宽度检测{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.MGridWidthValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MGridWidthBaseValue + model.MGridWidthUpFloatValue;
                        PtLower = model.MGridWidthBaseValue - model.MGridWidthDownFloatValue;
                    }
                    testName = "主栅宽度检测";
                    break;
                case 8502:
                    Log($"主栅间距值", $"主栅间距{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.MGridSpreadValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MGridSpreadBaseValue + model.MGridSpreadUpFloatValue;
                        PtLower = model.MGridSpreadBaseValue - model.MGridSpreadDownFloatValue;
                    }
                    testName = "主栅间距";
                    break;
                case 8602:
                    Log($"细栅间距检测值", $"细栅间距检测{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.FGridSpreadValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.FGridSpreadBaseValue + model.FGridSpreadUpFloatValue;
                        PtLower = model.FGridSpreadBaseValue - model.FGridSpreadDownFloatValue;
                    }
                    testName = "细栅间距检测";
                    break;
                case 8702:
                    Log($"主栅长度检测值", $"主栅长度检测{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.MGridLengthValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MGridLengthBaseValue + model.MGridLengthUpFloatValue;
                        PtLower = model.MGridLengthBaseValue - model.MGridLengthDownFloatValue;
                    }
                    testName = "主栅长度检测";
                    break;
                case 8802:
                    Log($"Mark点横向间距值", $"Mark点横向间距{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.MarkXDisValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MarkXDisBaseValue + model.MarkXDisUpFloatValue;
                        PtLower = model.MarkXDisBaseValue - model.MarkXDisDownFloatValue;
                    }
                    testName = "Mark点横向间距";
                    break;
                case 8902:
                    Log($"Mark点竖向间距值", $"Mark点竖向间距{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.MarkYDisValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.MarkYDisBaseValue + model.MarkYDisUpFloatValue;
                        PtLower = model.MarkYDisBaseValue - model.MarkYDisDownFloatValue;
                    }
                    testName = "Mark点竖向间距";
                    break;
                case 9102:
                    Log($"鱼叉口长值", $"鱼叉口长{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.ForkLengthValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.ForkLengthBaseValue + model.ForkLengthUpFloatValue;
                        PtLower = model.ForkLengthBaseValue - model.ForkLengthDownFloatValue;
                    }
                    testName = "鱼叉口长";
                    break;
                case 9302:
                    Log($"鱼叉口间距值", $"鱼叉口间距{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.ForkDisValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.ForkDisBaseValue + model.ForkDisUpFloatValue;
                        PtLower = model.ForkDisBaseValue - model.ForkDisDownFloatValue;
                    }
                    testName = "鱼叉口间距检测";
                    break;
                case 9402:
                    Log($"蜈蚣角长值", $"蜈蚣角长{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.ChilopodLengthValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.ChilopodLengthBaseValue + model.ChilopodLengthUpFloatValue;
                        PtLower = model.ChilopodLengthBaseValue - model.ChilopodLengthDownFloatValue;
                    }
                    testName = "蜈蚣角长检测";
                    break;
                case 9502:
                    Log($"分片间隔长值", $"分片间隔{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.ShardingDisValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.ShardingDisBaseValue + model.ShardingDisUpFloatValue;
                        PtLower = model.ShardingDisBaseValue - model.ShardingDisDownFloatValue;
                    }
                    testName = "分片间隔检测";
                    break;
                case 9602:
                    Log($"焊点长值", $"焊点长{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.WeldingSpotLengthValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.WeldingSpotLengthBaseValue + model.WeldingSpotLengthUpFloatValue;
                        PtLower = model.WeldingSpotLengthBaseValue - model.WeldingSpotLengthDownFloatValue;
                    }
                    testName = "焊点长检测";
                    break;
                case 9702:
                    Log($"焊点宽值", $"焊点宽{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.WeldingSpotWidthValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.WeldingSpotWidthBaseValue + model.WeldingSpotWidthUpFloatValue;
                        PtLower = model.WeldingSpotWidthBaseValue - model.WeldingSpotWidthDownFloatValue;
                    }
                    testName = "焊点宽检测";
                    break;
                case 9802:
                    Log($"焊点间隔值", $"焊点间隔{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    if (order != null)
                        order.WeldingSpotDisValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = model.WeldingSpotDisBaseValue + model.WeldingSpotDisUpFloatValue;
                        PtLower = model.WeldingSpotDisBaseValue - model.WeldingSpotDisDownFloatValue;
                    }
                    testName = "焊点间隔检测";
                    break;
                case 9902:
                    Log($"SP2主栅宽度值", $"SP2主栅宽度{lstTestData.Count}:{Math.Round(data + testParam.OffsetValue, 4)}");
                    //if (order != null)
                    //    order.WeldingSpotDisValue = aveData;
                    if (testParam.OpenUseLimit)
                    {
                        PtUpper = testParam.StandardValues + testParam.MaxLimit;
                        PtLower = testParam.StandardValues - testParam.MinLimit;
                    }
                    else
                    {
                        PtUpper = 0;
                        PtLower = 0;
                    }
                    testName = "SP2主栅宽度检测";
                    break;
                    #endregion
            }

            Max = PtUpper;
            Min = PtLower;
            TestName = testName;
        }
        /// <summary>
        /// 保存均值
        /// </summary>
        /// <param name="stepName"></param>
        /// <param name="testName"></param>
        /// <param name="AveData"></param>
        /// <param name="max"></param>
        /// <param name="min"></param>
        /// <returns></returns>
        private bool AddAverageData(string stepName,string testName, double AveData, double max, double min)
        {
            if (order.SizeDefectAverageInfoList == null)
                order.SizeDefectAverageInfoList = new List<SizeDefectAverageInfo>();
            //寻找对应测试项是否已经保存
            var temp = order.SizeDefectAverageInfoList.Where(x => (x.StepName.Contains(stepName) && x.PointCode.Contains(testName))).FirstOrDefault();
            if (temp == null)
            {
                //为保存数据存入
                order.SizeDefectAverageInfoList.Add(new SizeDefectAverageInfo()
                {
                    result = CurrStepResult == 2 ? 2 : 1,
                    Max = max,
                    Min = min,
                    PointCode = testName,
                    AverageData = AveData,
                    StepName = stepName,
                    ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                    CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                });
            }
            else
            {
                temp.AverageData = AveData;
                temp.Max = max;
                temp.Min = min; 
            }
            return true;
        }
        private bool PointTestDef(int stepIndex, string processName, string EngineName, string gbxBmpPath, bool asynRun, Product model, PointTestProp testParam, bool isPtLastPoint)
        {
            if (scannerCBmpQueue.Count < 1)
            {
                Log($"{stepIndex + 1}-{processName}", $"选点测试检测异常，无源图像!!", WarningEnum.Low);
                return false;
            }
            var bmpCBmpQueue = scannerCBmpQueue.Dequeue();
            Log($"{stepIndex + 1}-{processName}", $"开始选点检测,posX:{bmpCBmpQueue.PosX},posY:{bmpCBmpQueue.PosY},图像队列数量: {scannerCBmpQueue.Count}...");

            int testindex = 0;
            //判断测试项
            switch (testParam.TestType)
            {
                case PointTestType.Y轴方向PT值检测:
                    if(!isPtLastPoint)
                        testindex = 8101;
                    else
                        testindex = 8102;
                    break;
                case PointTestType.线宽正面:
                    testindex = 8001;
                    break;
                case PointTestType.反面检测:
                    testindex = 8002;
                    break;
                case PointTestType.X轴方向PT值检测:
                    if (!isPtLastPoint)
                        testindex = 8201;
                    else
                        testindex = 8202;
                    break;
                case PointTestType.主栅连接线检测:
                    if (!isPtLastPoint)
                        testindex = 8301;
                    else
                        testindex = 8302;
                    break;
                case PointTestType.主栅宽度检测:
                        testindex = 8005;
                    break;
                case PointTestType.主栅间距:
                    if (!isPtLastPoint)
                        testindex = 8501;
                    else
                        testindex = 8502;
                    break;
                case PointTestType.细栅间距检测:
                    if (!isPtLastPoint)
                        testindex = 8601;
                    else
                        testindex = 8602;
                    break;
                case PointTestType.背极宽度:
                    testindex = 8007;
                    break;
                case PointTestType.主栅长度检测:
                    if (!isPtLastPoint)
                        testindex = 8701;
                    else
                        testindex = 8702;
                    break;
                case PointTestType.Mark点横向间距:
                    if (!isPtLastPoint)
                        testindex = 8801;
                    else
                        testindex = 8802;
                    break;
                case PointTestType.Mark点竖向间距:
                    if (!isPtLastPoint)
                        testindex = 8901;
                    else
                        testindex = 8902;
                    break;
                case PointTestType.鱼叉口长:
                    if (!isPtLastPoint)
                        testindex = 9101;
                    else
                        testindex = 9102;
                    break;
                case PointTestType.鱼叉口宽:
                    testindex = 8003;
                    break;
                case PointTestType.鱼叉口间距:
                    if (!isPtLastPoint)
                        testindex = 9301;
                    else
                        testindex = 9302;
                    break;

                case PointTestType.蜈蚣角长:
                    if (!isPtLastPoint)
                        testindex = 9401;
                    else
                        testindex = 9402;
                    break;
                case PointTestType.蜈蚣角宽:
                    testindex = 8004;
                    break;

                case PointTestType.分片间隔:
                    if (!isPtLastPoint)
                        testindex = 9501;
                    else
                        testindex = 9502;
                    break;
                case PointTestType.焊点长:
                    if (!isPtLastPoint)
                        testindex = 9601;
                    else
                        testindex = 9602;
                    break;
                case PointTestType.焊点宽:
                    if (!isPtLastPoint)
                        testindex = 9701;
                    else
                        testindex = 9702;
                    break;
                case PointTestType.焊点间隔:
                    if (!isPtLastPoint)
                        testindex = 9801;
                    else
                        testindex = 9802;
                    break;
                case PointTestType.SP2主栅宽度:
                    if (!isPtLastPoint)
                        testindex = 9901;
                    else
                        testindex = 9902;
                    break;
                default:
                    Log($"{stepIndex + 1}-{processName}", $"参数不支持！", WarningEnum.High);                   
                    return false;

            }
            //需要偏移校正，index=0时不能异步 //10,20,30...　
            AutoResetEvent endEvent = new AutoResetEvent(false);
            //加入处理
            SizeLib.add(new SizeTask()
            {
                stepIndex = stepIndex,
                processName = processName,
                //sizeTag = sizeTag,
                engineName = EngineName,
                Himage = bmpCBmpQueue.Himage.Clone(),//bmp/file_path二选一，优先bmp
                file_path = bmpCBmpQueue.Path,
                drawingPagePath = gbxBmpPath,
                posX = bmpCBmpQueue.PosX,
                posY = bmpCBmpQueue.PosY,

                index = testindex,//PT
                ContoursAffineTrans1_Out = this.contoursAffineTrans1_Out,//只有777时才使用最近333输出的结果 
                //结果回调
                finishEvent = (res) =>
                {
                    try
                    {
                        int roundIndex = res.index % 10;
                        if (res.isSucceed)
                        {
                            string tagOutData = "";
                            
                            OnAutoRuning(new RunEventArgs(stepIndex,
                                $"index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData}"));
                            Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测完成 index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData} ");
                            //测量
                            //------TEST
                            if ((res.index == 8102)|| (res.index == 8202) || (res.index == 8302) || (res.index == 8402)
                            || (res.index == 8502) || (res.index == 8602) || (res.index == 8702) || (res.index == 8802)
                            || (res.index == 8902) || (res.index == 9102) || (res.index == 9202) || (res.index == 9302)
                            || (res.index == 9402) || (res.index == 9502) || (res.index == 9602) || (res.index == 9702)
                            || (res.index == 9802) || (res.index == 9902))
                            {
                                //PT测量 等两点测量
                                lock (lstTestData)
                                {
                                    lstTestData.Add(Math.Round(res.PT1 + testParam.OffsetValue, 4));

                                    double PtValue = Math.Round(lstTestData.Average(), 4);
                                    double PtUpper = 0;
                                    double PtLower = 0;
                                    string testName = "";
                                    //上下限设置
                                    GetLimitInfo(res.index, res.PT1, PtValue, model, testParam, out PtUpper, out PtLower, out testName);
                                    //OnAutoRuning(new RunEventArgs(22, lstTestData, model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue));

                                    //数据判定
                                    double judgData = 0;
                                    if (testParam.JudgmentData == DataJudgment.单点)
                                        judgData = Math.Round(res.PT1 + testParam.OffsetValue, 4);
                                    else
                                        judgData = Math.Round(lstTestData.Average(), 4);

                                    //存在上下限，判断是否为不合格
                                    if (PtUpper + PtLower > 0 && (judgData > PtUpper || judgData < PtLower))
                                    {
                                        //order.Qualified = false;
                                        CurrStepResult = 2;
                                    }
                                    else if ((testParam.JudgmentData == DataJudgment.均值)
                                    && (PtUpper + PtLower > 0 && !(judgData > PtUpper || judgData < PtLower)))
                                    {
                                        //order.Qualified = true;
                                        CurrStepResult = 0;
                                    }

                                    //添加均值数据
                                    AddAverageData(processName, testName, PtValue, PtUpper, PtLower);

                                    if (order.SizeDefectInfoList == null)
                                        order.SizeDefectInfoList = new List<SizeDefectInfo>();
                                    order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                    {
                                        result = CurrStepResult == 2 ? 2 : 1,
                                        X = res.posX,
                                        Y = res.posY,
                                        PointCode = testName,
                                        Data = Math.Round(res.PT1 + testParam.OffsetValue, 4),
                                        StepName = processName,
                                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        isAverage = false
                                    }); 

                                    if ((this.CurrPoinntCount + 1) < testParam.PointCnt)
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName, new List<double>(lstTestData.ToArray()), Math.Round(lstTestData.Average(), 4),
                                        Math.Round(lstTestData.Max(), 4), Math.Round(lstTestData.Min(), 4), 1, false));
                                    else
                                    {
                                        order.Qualified = CurrStepResult > 0 ? false : order.Qualified;
                                        order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                        {
                                            result = CurrStepResult == 2 ? 2 : 1,
                                            X = res.posX,
                                            Y = res.posY,
                                            PointCode = testName,
                                            Data = Math.Round(lstTestData.Average(), 4),
                                            StepName = processName,
                                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            isAverage = true
                                        });
                                        //打印
                                        PrintDataList(processName, testParam, PtValue, PtUpper, PtLower);
            
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName, new List<double>(lstTestData.ToArray()), Math.Round(lstTestData.Average(), 4),
                                        Math.Round(lstTestData.Max(), 4), Math.Round(lstTestData.Min(), 4), CurrStepResult > 0 ? 3 : 2, false));
                                    }
                                 }
                            }
                            //线宽，反面，背极宽度
                            else if ((res.index == 8001) || (res.index == 8002) || (res.index == 8007) || (res.index == 8003) || (res.index == 8004)
                            || (res.index == 8005))
                            {
                                //线宽测量 等单点测量
                                lock (lstTestData)
                                {
                                    double lineWidthValue = res.Shanxian > 0 ? Math.Round(res.Shanxian + testParam.OffsetValue, 4) : 0;
                                    lstTestData.Add(lineWidthValue);

                                    double LwValue = Math.Round(lstTestData.Average(), 4);
                                    double LwUpper = 0;
                                    double LwLower = 0;
                                    string testName = "";
                                    //上下限设置
                                    GetLimitInfo(res.index, lineWidthValue, LwValue, model, testParam, out LwUpper, out LwLower, out testName);                                  
                                    //OnAutoRuning(new RunEventArgs(23, lstTestData, model.LineWidthBaseValue + model.LineWidthUpFloatValue, model.LineWidthBaseValue - model.LineWidthDownFloatValue));

                                    //数据判定
                                    double judgData = 0;
                                    if (testParam.JudgmentData == DataJudgment.单点)
                                        judgData = lineWidthValue;
                                    else
                                        judgData = LwValue;
                                    //存在上下限，判断是否为不合格
                                    if (LwUpper + LwLower > 0 && (judgData > LwUpper || judgData < LwLower))
                                    {
                                        //order.Qualified = false;
                                        CurrStepResult = 2;
                                    }
                                    else if ((testParam.JudgmentData == DataJudgment.均值) 
                                    &&(LwUpper + LwLower > 0 && !(judgData > LwUpper || judgData < LwLower)))
                                    {           
                                        //order.Qualified = true;
                                        CurrStepResult = 0;
                                    }
                                    //添加均值数据
                                    AddAverageData(processName, testName, LwValue, LwUpper, LwLower);

                                    if (order.SizeDefectInfoList == null)
                                        order.SizeDefectInfoList = new List<SizeDefectInfo>();
                                    order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                    {
                                        result = CurrStepResult == 2 ? 2 : 1,
                                        X = res.posX,
                                        Y = res.posY,
                                        PointCode = testName,
                                        Data = lineWidthValue,
                                        StepName = processName,
                                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        isAverage = false
                                    });
                                    if ((this.CurrPoinntCount + 1) < testParam.PointCnt)
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName, new List<double>(lstTestData.ToArray()), Math.Round(lstTestData.Average(), 2),
                                        Math.Round(lstTestData.Max(), 4), Math.Round(lstTestData.Min(), 4), 1, false));
                                    else
                                    {
                                        order.Qualified = CurrStepResult > 0 ? false : order.Qualified;
                                        order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                        {
                                            result = CurrStepResult == 2 ? 2 : 1,
                                            X = res.posX,
                                            Y = res.posY,
                                            PointCode = testName,
                                            Data = Math.Round(lstTestData.Average(), 4),
                                            StepName = processName,
                                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            isAverage = true
                                        });
                                        //打印
                                        PrintDataList(processName, testParam, LwValue, LwUpper, LwLower);                     
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName, new List<double>(lstTestData.ToArray()), Math.Round(lstTestData.Average(), 2),
                                        Math.Round(lstTestData.Max(), 4), Math.Round(lstTestData.Min(), 4), CurrStepResult > 0 ? 3 : 2, false));
                                    }
                                }
                            } 
                            //其他距离检测
                            else 
                            {
                                ;
                            }

                        }
                        //失败
                        else
                        {
                            //------TEST
                            if ((res.index == 8102) || (res.index == 8202) || (res.index == 8302) || (res.index == 8402)
                            || (res.index == 8502) || (res.index == 8602) || (res.index == 8702) || (res.index == 8802)
                            || (res.index == 8902) || (res.index == 9102) || (res.index == 9202) || (res.index == 9302)
                            || (res.index == 9402) || (res.index == 9502) || (res.index == 9602) || (res.index == 9702)
                            || (res.index == 9802) || (res.index == 9902))
                            {
                                //PT测量
                                lock (lstTestData)
                                {
                                    lstTestData.Add(0);
                                    double PtValue = Math.Round(lstTestData.Average(), 4);
                                    string testName = "";
                                    double PtUpper = 0;
                                    double PtLower = 0;
                                    GetLimitInfo(res.index, 0, PtValue, model, testParam, out PtUpper, out PtLower, out testName);
                                    //OnAutoRuning(new RunEventArgs(stepIndex, processName, lstPT, Math.Round(lstPT.Average(), 4),
                                    //    Math.Round(lstPT.Max(), 4), Math.Round(lstPT.Min(), 4), 3, false));

                                    order.Qualified = false;
                                    CurrStepResult = 2;

                                    //添加均值数据
                                    AddAverageData(processName, testName, PtValue, PtUpper, PtLower);
                                    if (order.SizeDefectInfoList == null)
                                        order.SizeDefectInfoList = new List<SizeDefectInfo>();
                                    order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                    {
                                        result = CurrStepResult == 2 ? 2 : 1,
                                        X = res.posX,
                                        Y = res.posY,
                                        PointCode = testName,
                                        Data = 0,
                                        StepName = processName,
                                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        isAverage = false
                                    });

                                    if ((this.CurrPoinntCount + 1) < testParam.PointCnt)
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName + ":检测失败", new List<double>(lstTestData.ToArray()), Math.Round(lstTestData.Average(), 4),
                                        Math.Round(lstTestData.Max(), 4), Math.Round(lstTestData.Min(), 4), 1, false));
                                    else
                                    {
                                        order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                        {
                                            result = CurrStepResult == 2 ? 2 : 1,
                                            X = res.posX,
                                            Y = res.posY,
                                            PointCode = testName,
                                            Data = Math.Round(lstTestData.Average(), 4),
                                            StepName = processName,
                                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            isAverage = true
                                        });
                                        PrintDataList(processName, testParam, PtValue, PtUpper, PtLower);
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName + ":检测失败", new List<double>(lstTestData.ToArray()), Math.Round(lstTestData.Average(), 4),
                                        Math.Round(lstTestData.Max(), 4), Math.Round(lstTestData.Min(), 4), CurrStepResult > 0 ? 3 : 2, false));
                                    }
                                }
                            }
                            //------
                            else if ((res.index == 8001) || (res.index == 8002) || (res.index == 8007) || (res.index == 8003) || (res.index == 8004)
                            || (res.index == 8005))
                            {
                                //线宽测量
                                lock (lstTestData)
                                {
                                    lstTestData.Add(0);
                                    double LwValue = Math.Round(lstTestData.Average(), 2);
                                    string testName = "";
                                    double LwUpper = 0;
                                    double LwLower = 0;
                                    GetLimitInfo(res.index, 0, LwValue, model, testParam, out LwUpper, out LwLower, out testName);
       
                                    order.Qualified = false;
                                    CurrStepResult = 2;

                                    //添加均值数据
                                    AddAverageData(processName, testName, LwValue, LwUpper, LwLower);
                                    if (order.SizeDefectInfoList == null)
                                        order.SizeDefectInfoList = new List<SizeDefectInfo>();
                                    order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                    {
                                        result = CurrStepResult == 2 ? 2 : 1,
                                        X = res.posX,
                                        Y = res.posY,
                                        PointCode = testName,
                                        Data = 0,
                                        StepName = processName,
                                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                        isAverage = false
                                    });
                                    if ((this.CurrPoinntCount + 1) < testParam.PointCnt)
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName + ":检测失败", lstTestData, Math.Round(lstTestData.Average(), 2),
                                        Math.Round(lstTestData.Max(), 2), Math.Round(lstTestData.Min(), 2), 1, false));
                                    else
                                    {
                                        order.SizeDefectInfoList.Add(new SizeDefectInfo()
                                        {
                                            result = CurrStepResult == 2 ? 2 : 1,
                                            X = res.posX,
                                            Y = res.posY,
                                            PointCode = testName,
                                            Data = Math.Round(lstTestData.Average(), 4),
                                            StepName = processName,
                                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                            isAverage = true
                                        });
                                        PrintDataList(processName, testParam, LwValue, LwUpper, LwLower);
                                        OnAutoRuning(new RunEventArgs(stepIndex, processName + ":检测失败", lstTestData, Math.Round(lstTestData.Average(), 2),
                                        Math.Round(lstTestData.Max(), 2), Math.Round(lstTestData.Min(), 2), CurrStepResult > 0 ? 3 : 2, false));
                                    }
                                }
                            }
                            //OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"失败:{res.resultInfo}"));
                            Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测失败index:{res.index}:{res.resultInfo}");

                        }

                        //保存
                        if (confMgr.SysConfigParams.SizeBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeBigImag.SavePath))
                        {
                            string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                            path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{model.StepInfo.Name}.bmp";
                            if (res.Himage != null)
                                HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                            else
                                API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                        }
                    }
                    catch (Exception ex)
                    {
                        Log($"{res.stepIndex + 1}-{res.processName}", $"单点检测回调处理异常 index:{res.index}，ex={ex.Message}");
                    }
                    endEvent.Set();//roundIndex＝０成功或失败线程返回
                                   //---
                    if (res.Himage != null)
                    {
                        res.Himage.Dispose();
                        res.Himage = null;
                    }
                    else
                    {
                        API.DeleteFile(res.file_path);
                    }
                }
            });

            //需等上面异步回调中的相对偏移校正完成再继续
            if (!asynRun)
            {
                if (!endEvent.WaitOne(60000))
                {
                    Log($"{stepIndex + 1}-{processName}", $"单点检测等待超时，忽略继续！", WarningEnum.Low);
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region 比对处理
        private bool SizeComp(int stepIndex, string processName, string EngineName, string gbxBmpPath, string picName, bool asynRun)
        {
            if (scannerCBmpQueue.Count < 1)
            {
                Log($"{stepIndex + 1}-{processName}", $"比对检测异常，无源图像!!", WarningEnum.Low);
                return false;
            }
            var bmpCBmpQueue = scannerCBmpQueue.Dequeue();
            Log($"{stepIndex + 1}-{processName}", $"开始比对检测,posX:{bmpCBmpQueue.PosX},posY:{bmpCBmpQueue.PosY},图像队列数量: {scannerCBmpQueue.Count}...");

            //需要偏移校正，index=0时不能异步 //10,20,30...　
            AutoResetEvent endEvent = new AutoResetEvent(false);
            SizeLib.add(new SizeTask()
            {
                stepIndex = stepIndex,
                processName = processName,
                //sizeTag = sizeTag,
                engineName = EngineName,
                Himage = bmpCBmpQueue.Himage.Clone(),//bmp/file_path二选一，优先bmp
                file_path = bmpCBmpQueue.Path,
                drawingPagePath = gbxBmpPath,
                posX = bmpCBmpQueue.PosX,
                posY = bmpCBmpQueue.PosY,
                
                index = 777,// 比对
                ContoursAffineTrans1_Out = this.contoursAffineTrans1_Out,//只有777时才使用最近333输出的结果 
                finishEvent = (res) =>
                {
                    try
                    {
                        //比对
                        if (res.index == 777)//比对
                        {
                            if (res.isSucceed)
                            {
                                //界面显示
                                //OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}-{compBmpIndex}，posX:{res.posX},posY:{res.posY},图像比对:{(res.CompResult ? "通过" : "未通过")} "));
                                Log($"{res.stepIndex + 1}-{res.processName}", $"图像比对，index:{res.index}-{compBmpIndex},posX:{res.posX},posY:{res.posY}，结果:{(res.CompResult ? "通过" : "未通过")}");
                                // 
                                if (order.CompareResult < 2)
                                    order.CompareResult = res.CompResult ? 1 : 2;
                                if (!res.CompResult)
                                {
                                    //不合格
                                    order.Qualified = false;
                                }
                                //更新比对看板 对比置零3
                                if (!res.CompResult)
                                    SizeNGCnt++;
                                if (SizeNGCnt > 0)
                                    OnAutoRuning(new RunEventArgs(res.stepIndex, $"图像比对-未通过:index:{res.index}-{compBmpIndex},posX:{res.posX},posY:{res.posY}，结果:{(res.CompResult ? "通过" : "未通过")}", new List<double>(), 0, SizeNGCnt, 0, 1, true));
                                //OnAutoRuning(new RunEventArgs(3, false, SizeNGCnt));
                                else
                                    OnAutoRuning(new RunEventArgs(res.stepIndex, $"图像比对-通过:index:{res.index}-{compBmpIndex},posX:{res.posX},posY:{res.posY}，结果:{(res.CompResult ? "通过" : "未通过")}", new List<double>(), 0, SizeNGCnt, 0, 1, true));
                                //OnAutoRuning(new RunEventArgs(3, true, SizeNGCnt));
                                if (!res.CompResult)
                                {
                                    Log($"{res.stepIndex + 1}-{res.processName}", $"图像比对，未通过结果:{JsonConvert.SerializeObject(res.defectInfor2RestorationDesk)}");
                                    //转为图纸上坐标位置
                                    if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)
                                    {
                                        //AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"转换到图纸后坐标数据：{JsonConvert.SerializeObject(res.defectInfor2RestorationDeskPage)}");
                                        if (order.DefectInfoList == null)
                                            order.DefectInfoList = new List<DefectInfo>();
                                        foreach (var item in res.defectInfor2RestorationDeskPage)
                                            order.DefectInfoList.Add(new DefectInfo()
                                            {
                                                Type = 1,
                                                Code = item[3],
                                                X = double.Parse(item[1]),
                                                Y = double.Parse(item[2]),
                                                ZXD = double.Parse(item[4]),
                                                ModifyUserCode = userMgr.LoginUser.Code,
                                                CreateUserCode = userMgr.LoginUser.Code,
                                            });
                                    }

                                    //比对失败的图片 -- 用于修复台调用
                                    Bitmap bmpCompareFailZoomImage = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.Zoom_Image_mat);
                                    lstCompareFailZoomImage.Add(bmpCompareFailZoomImage);
                                    if (confMgr.SysConfigParams.SizeRepairImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeRepairImag.SavePath))
                                    {
                                        string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeRepairImag.SavePath,
                                            new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                        //path += $"Size_SN{order.SN}_I{res.index}_X{res.Defects_X}_Y{res.Defects_Y}_C0_{ model.StepInfo.Name}";
                                        path += $"Size_SN{order.SN}_I{compBmpIndex}_X{res.posX}_Y{res.posY}_C0_{picName}";
                                        lock (ImageSaveObj)
                                        {
                                            bmpCompareFailZoomImage.Save(path + ".bmp", ImageFormat.Bmp);
                                            if (res.defectInfor2RestorationDesk != null && res.defectInfor2RestorationDesk.Count > 0)
                                                File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.defectInfor2RestorationDesk));
                                        }
                                    }
                                    //保存不良原图
                                    if (confMgr.SysConfigParams.SizeNGImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.SizeNGImag.SavePath))
                                    {
                                        string path = Util.CreateSubDir(confMgr.SysConfigParams.SizeNGImag.SavePath,
                                            new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                        path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{picName}.bmp";
                                        Log($"{res.stepIndex + 1}-{processName}", $"未通过图片保存:{path}");
                                        if (res.Himage != null)
                                            HOperatorSet.WriteImage(res.Himage, "bmp", 0, path);
                                        else
                                            API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 
                                    }
                                }
                            }
                            else
                            {
                                order.CompareResult = 2;
                                order.Qualified = false;
                                SizeNGCnt++;
                                OnAutoRuning(new RunEventArgs(res.stepIndex, $"图像比对失败，index:{res.index}-{compBmpIndex}.", new List<double>(), 0, SizeNGCnt, 0, 1, true));
                                //OnAutoRuning(new RunEventArgs(3, false, SizeNGCnt));
                                //OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"index:{res.index}，图像比对失败！"));
                                Log($"{res.stepIndex + 1}-{res.processName}", $"图像比对失败，index:{res.index}-{compBmpIndex}.", WarningEnum.Low);
                            }
                            compBmpIndex++;
                        }                       
                    }
                    catch (Exception ex)
                    {
                        Log($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测回调处理异常 index:{res.index}，ex={ex.Message}");
                    }
                    endEvent.Set();//roundIndex＝０成功或失败线程返回
                                   //---
                    if (res.Himage != null)
                    {
                        res.Himage.Dispose();
                        res.Himage = null;
                    }
                    else
                    {
                        API.DeleteFile(res.file_path);
                    }
                }
            });
            compBmpNum++;

            //需等上面异步回调中的相对偏移校正完成再继续
            if (!asynRun)
            {
                if (!endEvent.WaitOne(60000))
                {
                    Log($"{stepIndex + 1}-{processName}", $"比对等待超时，忽略继续！", WarningEnum.Low);
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region 缺陷处理
        private bool DefectPicture(int stepIndex, string processName,SizeDefectProp param, string gbxBmpPath, Product md, string picName)
        {
            if (scannerGBmpQueue.Count < 1)
            {
                Log($"{stepIndex + 1}-{processName}", $"缺陷检测异常，无源图像!!", WarningEnum.Low);
                return false;
            }
            var bmpLoc = scannerGBmpQueue.Dequeue();
            Log($"{stepIndex + 1}-{processName}", $"开始缺陷检测，源图索引:{defectBmpNum},图像队列数量: {scannerGBmpQueue.Count}...");
            //string[] aarCut_size = param.CutSize;
            //string[] aarResize = processParam.Value<string>("Resize").Split(',');

            //获取模型类型
            string modeltp;
            Classes tClasses = svcClasses.GetById(md.ClassesId);
            if (tClasses.Name == "乳剂")
                modeltp = "rj";
            else
                modeltp = "pt";
            defectLib.add(new DefectTask()
            {
                stepIndex = stepIndex,
                processName = processName,
                modelType = modeltp,
                drawingPagePath = gbxBmpPath,
                //index = defectBmpNum++,
                index = defectBmpNum,
                bmp = bmpLoc.bmp.Clone(),
                Xmm = bmpLoc.Xmm,
                Ymm = bmpLoc.Ymm,
                cut_size = new System.Drawing.Size(param.CutSize.Width, param.CutSize.Height),
                resize = new System.Drawing.Size(param.Resize.Width, param.Resize.Height),
                thresholds = param.Thresholds,
                thresholdsClass = param.ThresholdsClass,
                recAreaThreshold = getProductAreaThreshol(md), //qxName,面积; qxName,面积; qxName,面积;
                finishEvent = (res) =>
                {
                    if (res.isSucceed)
                    {
                        //界面显示
                        OnAutoRuning(new RunEventArgs(res.stepIndex, $"缺陷检测完成(源图索引:{res.index})，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}",
                            new List<double>(), 1, 1, res.defectCount, 1, true));
                        //OnAutoRuning(new RunEventArgs(liStatocStepIndex,
                        //    $"源图索引:{res.index}，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}"));
                        Log($"{res.stepIndex + 1}-{res.processName}", $"缺陷检测完成(源图索引:{res.index})，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}");
                        string path;
                        if (res.defectCount > 0)
                        {
                            //UI显示小图 (含统计缺陷类型数量)
                            AllDefectCount += res.informationList.Count;
                            showDefectSmallBmps(res.bmps_tag, res.bmps_cut, res.Xmm, res.Ymm, res.informationList);
                            if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)
                            {
                                Log($"{res.stepIndex + 1}-{res.processName}", $"转换后坐标数据：{JsonConvert.SerializeObject(res.defectInfor2RestorationDeskPage)}");
                                if (order.DefectInfoList == null)
                                    order.DefectInfoList = new List<DefectInfo>();
#if false                              
                                foreach (var item in res.defectInfor2RestorationDeskPage)
                                order.DefectInfoList.Add(new DefectInfo()
                                {
                                    Type = 0,
                                    Code = item[3],
                                    X = double.Parse(item[1]),
                                    Y = double.Parse(item[2]),
                                    ZXD = double.Parse(item[4]), 
                                    Index = int.Parse(item[0]),
                                    Area = item.Count>5?double.Parse(item[5]):0,
                                    ModifyUserCode = UserMgr.LoginUser.Code,
                                    CreateUserCode = UserMgr.LoginUser.Code,
                                });
#else
                                for (int i = 0; i < res.defectInfor2RestorationDeskPage.Count; i++)
                                {
                                    double n;
                                    order.DefectInfoList.Add(new DefectInfo()
                                    {
                                        Type = 0,
                                        Code = res.defectInfor2RestorationDeskPage[i][3],
                                        X = double.Parse(res.defectInfor2RestorationDeskPage[i][1]),
                                        Y = double.Parse(res.defectInfor2RestorationDeskPage[i][2]),
                                        ZXD = double.Parse(res.defectInfor2RestorationDeskPage[i][4]),
                                        Index = int.Parse(res.defectInfor2RestorationDeskPage[i][0]),
                                        Area = ((res.defectInfor2RestorationDesk[i].Count > 5 )&& (double.TryParse(res.defectInfor2RestorationDesk[i][5], out n))) ? double.Parse(res.defectInfor2RestorationDesk[i][5]) : 0,
                                        ModifyUserCode = UserMgr.LoginUser.Code,
                                        CreateUserCode = UserMgr.LoginUser.Code,
                                    });
                                }
                                    
#endif
                            }
                            //保存原始大图
                            if (confMgr.SysConfigParams.DefectBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectBigImag.SavePath))
                            {
                                path = Util.CreateSubDir(confMgr.SysConfigParams.DefectBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{picName}";
                                lock (ImageSaveObj)
                                {
                                    res.bmp.ImWrite(path + ".bmp");
                                    //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save(path + ".bmp", ImageFormat.Bmp);
                                    File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.informationList));
                                }
                            }

                            //保存小图
                            if (confMgr.SysConfigParams.DefectSmallImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectSmallImag.SavePath))
                            {
                                //2024-03-07 图片index计算
                                List<string> indexList = new List<string>();
                                if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)
                                    foreach (var item in res.defectInfor2RestorationDeskPage)
                                    {
                                        if (indexList.Count == 0)
                                            indexList.Add(item[0]);
                                        else
                                        {
                                            if (!indexList.Contains(item[0]))
                                                indexList.Add(item[0]);
                                        }
                                    }

                                path = Util.CreateSubDir(confMgr.SysConfigParams.DefectSmallImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_{picName}";

                                if (res.bmps_tag.Count() != indexList.Count)
                                    Log($"{res.stepIndex + 1}-{res.processName}", $"缺陷图片张数和index对不上：{res.bmps_tag.Count()} - {indexList.Count}", WarningEnum.Low);
                                for (int i = 0; i < res.bmps_tag.Count(); i++)
                                {
                                    lock (ImageSaveObj)
                                    {
                                        if (res.bmps_tag.Count() != indexList.Count)
                                            res.bmps_tag[i].Save(path + $"_i{i}_{i}.bmp", ImageFormat.Bmp);
                                        else
                                            res.bmps_tag[i].Save(path + $"_i{i}_{indexList[i]}.bmp", ImageFormat.Bmp);
                                    }
                                    //res.bmps_tag[i].Save(path + $"_i{i}.bmp", ImageFormat.Bmp);
                                    //res.bmps_tag[i].Save(path + $"{indexList[i]}.bmp", ImageFormat.Bmp);
                                }
                            }

                            //保存压缩大图 -- 用于修复台调用
                            if (confMgr.SysConfigParams.DefectRepairImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectRepairImag.SavePath))
                            {
                                path = Util.CreateSubDir(confMgr.SysConfigParams.DefectRepairImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{picName}";
                                lock (ImageSaveObj)
                                {
                                    res.bmpCompress.ImWrite(path + ".bmp");
                                    //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmpCompress).Save(path + ".bmp", ImageFormat.Bmp);
                                    File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.defectInfor2RestorationDesk));
                                }
                            }
                        }
                        else//没有缺陷
                        {
                            if (confMgr.SysConfigParams.SaveAllImg && confMgr.SysConfigParams.DefectBigImag.SavePath != "" && Directory.Exists(confMgr.SysConfigParams.DefectBigImag.SavePath))
                            {
                                path = Util.CreateSubDir(confMgr.SysConfigParams.DefectBigImag.SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });
                                path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{picName}";
                                lock (ImageSaveObj)
                                {
                                    res.bmp.ImWrite(path + ".bmp");
                                    //OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save(path + ".bmp", ImageFormat.Bmp);
                                }

                            }
                        }
                    }
                    else
                    {
                        OnAutoRuning(new RunEventArgs(res.stepIndex, $"缺陷检测失败:{res.resultInfo}", new List<double>(), 1, -1, -1, 1, true));
                        //OnAutoRuning(new RunEventArgs(liStatocStepIndex, $"失败:{res.resultInfo}"));
                        Log($"{res.stepIndex + 1}-{res.processName}", $"缺陷检测失败:{res.resultInfo}");
                        //暂停 这里不能暂停，stepIndex和scannerBmpQueue队列也不对了
                    }
                    defectBmpNumResult++;
                    foreach (var item in res.bmps_cut)
                        item.Dispose();
                    res.bmp.Dispose();
                    res.bmp = null;
                    res.bmps_tag = null;
                    if (res.bmpCompress != null)
                    {
                        res.bmpCompress.Dispose();
                        res.bmpCompress = null;
                    }
                    System.GC.Collect();
                }
            });
            defectBmpNum++;
            return true;
        }
        #endregion

        #region 添加缺陷打印信息
        private void AddDefectPrintInfo(SizeDefectProp defectParam)
        {
            if (defectParam.OpenPrint)
            {
                if (!string.IsNullOrEmpty(defectParam.ExcelDefectCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelDefectCount,
                        PrintCode = "ExcelDefectCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelDKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelDKCount,
                        PrintCode = "ExcelDKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelZWCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelZWCount,
                        PrintCode = "ExcelZWCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelGSYCCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelGSYCCount,
                        PrintCode = "ExcelGSYCCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelXWSCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelXWSCount,
                        PrintCode = "ExcelXWSCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelQKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelQKCount,
                        PrintCode = "ExcelQKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelZKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelZKCount,
                        PrintCode = "ExcelZKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelPPCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelPPCount,
                        PrintCode = "ExcelPPCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelHSCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelHSCount,
                        PrintCode = "ExcelHSCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelYXCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelYXCount,
                        PrintCode = "ExcelYXCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelXBCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelXBCount,
                        PrintCode = "ExcelXBCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelSXCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelSXCount,
                        PrintCode = "ExcelSXCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelDSCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelDSCount,
                        PrintCode = "ExcelDSCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelGSDLCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelGSDLCount,
                        PrintCode = "ExcelGSDLCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.ExcelCJDKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 0,
                        IsValue = false,
                        PrintKey = defectParam.ExcelCJDKCount,
                        PrintCode = "ExcelCJDKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
            }
            if (defectParam.OpenPrintLabel)
            {
                if (!string.IsNullOrEmpty(defectParam.LabelDefectCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelDefectCount,
                        PrintCode = "LabelDefectCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelDKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelDKCount,
                        PrintCode = "LabelDKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelZWCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelZWCount,
                        PrintCode = "LabelZWCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelGSYCCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelGSYCCount,
                        PrintCode = "LabelGSYCCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelXWSCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelXWSCount,
                        PrintCode = "LabelXWSCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelQKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelQKCount,
                        PrintCode = "LabelQKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelZKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelZKCount,
                        PrintCode = "LabelZKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelPPCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelPPCount,
                        PrintCode = "LabelPPCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelHSCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelHSCount,
                        PrintCode = "LabelHSCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelYXCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelYXCount,
                        PrintCode = "LabelYXCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelXBCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelXBCount,
                        PrintCode = "LabelXBCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelSXCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelSXCount,
                        PrintCode = "LabelSXCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelDSCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelDSCount,
                        PrintCode = "LabelDSCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelGSDLCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelGSDLCount,
                        PrintCode = "LabelGSDLCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
                if (!string.IsNullOrEmpty(defectParam.LabelCJDKCount))
                    CurrPrintInfos.Add(new PrintInfo()
                    {
                        Type = 1,
                        IsValue = false,
                        PrintKey = defectParam.LabelCJDKCount,
                        PrintCode = "LabelCJDKCount",
                        CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                        ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                    });
            }
        }
        #endregion

#endregion

        #region 日志图片删除
        #region 文件删除
        public void DelectPictureFile()
        {
            //删除文件
            Task.Factory.StartNew(() =>
            {
                //图片
                if (confMgr.SysConfigParams.DefectBigImag.AutoDelete)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectBigImag.SavePath, confMgr.SysConfigParams.DefectBigImag.AutoDeleteDays, true);
                if (confMgr.SysConfigParams.DefectSmallImag.AutoDelete)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectSmallImag.SavePath, confMgr.SysConfigParams.DefectSmallImag.AutoDeleteDays, true);
                if (confMgr.SysConfigParams.DefectRepairImag.AutoDelete)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.DefectRepairImag.SavePath, confMgr.SysConfigParams.DefectRepairImag.AutoDeleteDays, true);
                if (confMgr.SysConfigParams.SizeBigImag.AutoDelete)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.SizeBigImag.SavePath, confMgr.SysConfigParams.SizeBigImag.AutoDeleteDays, true);
                if (confMgr.SysConfigParams.SizeNGImag.AutoDelete)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.SizeNGImag.SavePath, confMgr.SysConfigParams.SizeNGImag.AutoDeleteDays, true);
                if (confMgr.SysConfigParams.SizeRepairImag.AutoDelete)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.SizeRepairImag.SavePath, confMgr.SysConfigParams.SizeRepairImag.AutoDeleteDays, true);
                //日志
                if (confMgr.SysConfigParams.AutoDeleteLog)
                    statusMgr.DeleteFiles(confMgr.SysConfigParams.LogPath, confMgr.SysConfigParams.AutoDeleteLogData, true);
            });
        }
        #endregion
        #endregion

        #region 系统事件显示回调
        /// <summary>
        /// 初始化回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void InitEventHandler(Object sender, InitEventArgs e);
        public event InitEventHandler InitRuning;
        protected virtual void OnInitRuning(InitEventArgs e)
        {
            if (null != InitRuning)
            {
                InitRuning(this, e);
            }
        }
        /// <summary>
        /// 流程回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void RunEventHandler(Object sender, RunEventArgs e);
        public event RunEventHandler AutoRuning;
        protected virtual void OnAutoRuning(RunEventArgs e)
        {
            if (null != AutoRuning)
            {
                AutoRuning(this, e);
            }
        }
        /// <summary>
        /// 显图回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void ImgEventHandler(Object sender, ImgEventArgs e);
        public event ImgEventHandler AutoShowImg;
        protected virtual void OnAutoShowImg(ImgEventArgs e)
        {
            if (null != AutoShowImg)
            {
                AutoShowImg(this, e);
            }
        }
        /// <summary>
        /// 主窗体回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public delegate void MainEventHandler(Object sender, MainEventArgs e);
        public event MainEventHandler MainRuning;
        protected virtual void OnMainRuning(MainEventArgs e)
        {
            if (null != MainRuning)
            {
                MainRuning(this, e);
            }
        }

        private void showDefectSmallBmps(Bitmap[] bmps, Mat[] bmps_cut, double Xmm, double Ymm, List<Dictionary<int, List<string>[]>> info)
        {
            OnAutoShowImg(new ImgEventArgs(bmps, bmps_cut, Xmm, Ymm, info));
        }
        #endregion

        #region 界面显示
        public static void showRowNum_onDataGrid_RowPostPaint(DataGridView dgv, object sender, DataGridViewRowPostPaintEventArgs e)
        {
            Rectangle rectangle = new Rectangle(e.RowBounds.Location.X, e.RowBounds.Location.Y, dgv.RowHeadersWidth - 4, e.RowBounds.Height);
            TextRenderer.DrawText(e.Graphics, (e.RowIndex + 1).ToString(), dgv.RowHeadersDefaultCellStyle.Font, rectangle, dgv.RowHeadersDefaultCellStyle.ForeColor, TextFormatFlags.VerticalCenter | TextFormatFlags.Right);
        }
        /// <summary>
        /// IO二进制数据格式化到8位 XXXX10X0
        /// </summary>
        /// <param name="datas"></param>
        /// <returns></returns>
        public static string[] IODataFormatBinaryStr(string[] datas, bool clone, char defaultPadChar = 'X')
        {
            string[] datas2 = new string[datas.Length];
            for (int i = 0; i < datas.Length; i++)
            {
                if (clone)
                {
                    datas2[i] = datas[i].Replace(" ", "");
                    if (datas2[i].Length > 8)
                        datas2[i] = datas2[i].Substring(datas2[i].Length - 8);
                    else if (datas2[i].Length < 8)
                        datas2[i] = datas2[i].PadLeft(8, defaultPadChar);
                }
                else
                {
                    datas[i] = datas[i].Replace(" ", "");
                    if (datas[i].Length > 8)
                        datas[i] = datas[i].Substring(datas[i].Length - 8);
                    else if (datas[i].Length < 8)
                        datas[i] = datas[i].PadLeft(8, defaultPadChar);

                    datas2 = datas;
                }
            }

            return datas2;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="op_show_list">[XXHL XXXX,XXXX XXXX,...]</param>
        /// <param name="currIoDatas">[byte,byte,byte,byte]</param>
        /// <returns></returns>
        public static bool compareIOInput(string[] op_show_list, byte[] currIoDatas)
        {
            int isok = 0;//1-true 2-false
            string IN_OP_SHOW;
            for (int i = 0; i < currIoDatas.Length; i++)
            {
                IN_OP_SHOW = op_show_list[i].Replace(" ", "").PadLeft(8, 'X');
                if (IN_OP_SHOW.IndexOf('H') < 0 && IN_OP_SHOW.IndexOf('L') < 0)
                    continue;

                for (int j = 7; j >= 0; j--)
                {
                    byte bit = (byte)(1 << 7 - j);
                    if (IN_OP_SHOW[j] == 'H')
                    {
                        if ((bit & currIoDatas[i]) > 0)
                            isok = 1;
                        else
                        {
                            isok = 2;
                            break;
                        }
                    }
                    else if (IN_OP_SHOW[j] == 'L')
                    {
                        if ((currIoDatas[i] ^ (currIoDatas[i] | bit)) > 0)
                            isok = 1;
                        else
                        {
                            isok = 2;
                            break;
                        }
                    }
                }

                //已经不符
                if (isok == 2) break;
            }

            //
            return isok == 1;
        }

        #endregion

        #region 硬盘检测
        public static bool CheckDisk(IWin32Window owner, int max = 10)
        {
            string path = ConfMgr.Instance.SysConfigParams.DefectBigImag.SavePath;
            string volume = path.Substring(0, path.IndexOf(':'));
            long freespace = DiskAPI.GetHardDiskSpace(volume);
            if (freespace < max)
            {
                string tip = $"当前{volume}硬盘容量：{freespace}GB，小于{max}GB。注意清理！！";
                FrmDialog.ShowDialog(owner, tip, "警告", true);
                return false;
            }
            return true;
        }
        #endregion

        #region 自动聚焦

        public bool AutoFocus(double FocusStep, double DirStep, int waitTime, int Timeout)
        {
            DateTime dt;
            double step = FocusStep;
            double dir_step = DirStep;

            int axisno = (int)AxisName.Axis3;

            double z = GetAxisPosValueMM(axisno);
            double mean = 0;
            double z_hpos = 0;
            int cnt = 0;
            int dir = 0;
            DateTime alldt = DateTime.Now;
            Yolo_Class yolo = new Yolo_Class();

            //寻找方向
            dt = DateTime.Now;
            while (true)
            {
                double pos = GetAxisPosValueMM(axisno);               
                camDevFront.ClearImageQueue();
                Acquisition acq = camDevFront.Snap(1, 5000);
                if (acq.GrabStatus == "GrabPass")
                { 
                    //显示
                    OnAutoRuning(new RunEventArgs(0, acq.Image));               
                    yolo.FocusDirec(acq.Image.CopyObj(1, -1), ref dir, ref mean, ref z_hpos);
                    cnt++;

                    if ((cnt > 2) && (dir != 0))
                    {
                        Log("自动找方向", $"步进次数:{cnt},位置:{pos}, 反馈方向:{dir}, 反馈位置:{z_hpos}, 步进:{dir_step}");
                        break;
                    }

                    VelocityCurveParams velocityCurve = new VelocityCurveParams(100, 100, 5, 100, 0, 1000);
                    //axisDev.MoveAbsValue(axisno, velocityCurve, z - cnt * dir_step);
                    if (cnt == 1)
                    {
                        mean = 0;
                        Log("自动找方向", $"步进次数:{cnt},位置:{pos}, mean:{mean}, 反馈方向:{dir}, 反馈位置:{z_hpos}");
                        axisDev.MoveAbsValue(axisno, velocityCurve, z_hpos);
                        axisDev.CheckDone(axisno, 20);
                    }
                    else 
                    {
                        Log("自动找方向", $"步进次数:{cnt},位置:{pos},  mean:{mean}, 反馈方向:{dir}, 反馈位置:{z_hpos}, 步进:{dir_step}");
                        axisDev.MoveAbsValue(axisno, velocityCurve, pos - dir_step);
                        axisDev.CheckDone(axisno, 20);
                       
                    }
                    //Log("自动找方向", $"步进次数:{cnt},位置:{z_hpos - cnt * dir_step}, 反馈:{dir}");   
                }
                else
                {
                    Log("自动找方向", $"拍照失败！");
                    return false;
                }
                if((DateTime.Now - dt).TotalMilliseconds > Timeout)
                {
                    return false;
                }
                Thread.Sleep(waitTime);
            }

            cnt = 0;
            mean = 0;
            z = GetAxisPosValueMM(axisno);
            //dt = DateTime.Now;
            //聚焦
            while (true)
            {
                double pos = GetAxisPosValueMM(axisno);
                camDevFront.ClearImageQueue();
                Acquisition acq = camDevFront.Snap(1, 1000);
                if (acq.GrabStatus == "GrabPass")
                {
                    //显示
                    OnAutoRuning(new RunEventArgs(0, acq.Image));

                    yolo.Focus(acq.Image.CopyObj(1, -1), step, ref dir, ref z, ref mean);
                    cnt++;
                    Log("自动聚焦", $"方向:{dir},下次目标位置:{z},次数:{cnt},反馈:{mean},Z轴当前实际位置:{pos}");
                    if (mean == 9999)
                    {
                        break;
                    }
                    VelocityCurveParams velocityCurve = new VelocityCurveParams(100, 100, 5, 100, 0, 1000);
                    axisDev.MoveAbsValue(axisno, velocityCurve, z);
                    axisDev.CheckDone(axisno, 20);
                    if ((DateTime.Now - alldt).TotalMilliseconds > Timeout)
                    {
                        return false;
                    }

                }
                else
                {
                    Log("自动找方向", $"拍照失败！");
                    return false;
                }
                if ((DateTime.Now - alldt).TotalMilliseconds > Timeout)
                {
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region 打印
        /// <summary>
        /// 打印数据
        /// </summary>
        /// <param name="printerType"></param>
        /// <param name="printerName"></param>
        /// <param name="printerTemp"></param>
        /// <param name="data"></param>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool PrintFileData(PrinterType printerType, string printerName, string printerTemp, Dictionary<string, string> data, Product model) 
        {
            bool ret = true;
            try
            {
                //Log("标签打印", $"打印机:{printerName}, 模板路径={printerTemp}");
                if (printerType == PrinterType.Label)
                {
                    if (!printControl.BarTenderOpenFile(printerTemp))
                        ret = false;
                }
                else if (printerType == PrinterType.Excel)
                {
                    if (!printControl.ExcelOpenFile(printerTemp))
                        ret = false;
                }
                Dictionary<string, string> printData = new Dictionary<string, string>();
                if (ret)
                {
                    if (data != null)
                    {
                        foreach (var item in data)
                        {
                            string value = "";
                            foreach (var s in System.Enum.GetValues(typeof(PrintDataEnum)))
                            {
                                PrintDataEnum dataEnum = (PrintDataEnum)s;
                                if (dataEnum.GetDescription() == item.Value)
                                {
                                    switch (dataEnum)
                                    {
                                        case PrintDataEnum.BatchId:
                                            value = order.BatchId;
                                            break;
                                        case PrintDataEnum.CompareResult:
                                            value = order.CompareResult == 0 ? "未比对" : order.CompareResult == 1 ? "OK" : "NG";
                                            break;
                                        case PrintDataEnum.Qualified:
                                            value = order.Qualified ? "合格" : "不合格";
                                            break;
                                        case PrintDataEnum.OrderCode:
                                            value = order.OrderCode;
                                            break;
                                        case PrintDataEnum.OrderName:
                                            if (model != null)
                                                value = model.Name;
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.SN:
                                            value = order.SN;
                                            break;
                                        case PrintDataEnum.DetectOrder:
                                            value = order.DetectOrder;
                                            break;
                                        case PrintDataEnum.Time:
                                            value = order.CreateTime.ToString("yyyy/MM/dd HH:mm");
                                            break;
                                        case PrintDataEnum.OperatorName:
                                            value = userMgr.LoginUser.Name;
                                            break;

                                        case PrintDataEnum.TensionValue:
                                            value = order.TensionValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.HeightValue:
                                            value = order.HeightValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.LineWidthValue:
                                            value = order.LineWidthValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.PTValue:
                                            value = order.PTValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.XPTValue:
                                            value = order.XPTValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.FLineWidthValue:
                                            value = order.FLineWidthValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.MGridIntervalValue:
                                            value = order.MGridIntervalValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.MGridWidthValue:
                                            value = order.MGridWidthValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.MGridSpreadValue:
                                            value = order.MGridSpreadValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.FGridSpreadValue:
                                            value = order.FGridSpreadValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.BackPoleWidthValue:
                                            value = order.BackPoleWidthValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.MGridLengthValue:
                                            value = order.MGridLengthValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.MarkXDisValue:
                                            value = order.MarkXDisValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.MarkYDisValue:
                                            value = order.MarkYDisValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.ForkLengthValue:
                                            value = order.ForkLengthValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.ForkWidthValue:
                                            value = order.ForkWidthValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.ForkDisValue:
                                            value = order.ForkDisValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.ChilopodLengthValue:
                                            value = order.ChilopodLengthValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.ChilopodWidthValue:
                                            value = order.ChilopodWidthValue.ToString("0.000");
                                            break;
                                        case PrintDataEnum.ShardingDisValue:
                                            value = order.ShardingDisValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.WeldingSpotDisValue:
                                            value = order.WeldingSpotDisValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.WeldingSpotLengthValue:
                                            value = order.WeldingSpotLengthValue.ToString("0.0000");
                                            break;
                                        case PrintDataEnum.WeldingSpotWidthValue:
                                            value = order.WeldingSpotWidthValue.ToString("0.0000");
                                            break;



                                        case PrintDataEnum.TensionValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.TensionBaseValue + model.TensionUpFloatValue}\r\n下限:{model.TensionBaseValue - model.TensionDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.HeightValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.HeightBaseValue + model.HeightUpFloatValue}\r\n下限:{model.HeightBaseValue - model.HeightDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.LineWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.LineWidthBaseValue + model.LineWidthUpFloatValue}\r\n下限:{model.LineWidthBaseValue - model.LineWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.PTValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.PTBaseValue + model.PTUpFloatValue}\r\n下限:{model.PTBaseValue - model.PTUpFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.XPTValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.PTXBaseValue + model.PTXUpFloatValue}\r\n下限:{model.PTXBaseValue - model.PTXUpFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.FLineWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.FLineWidthBaseValue + model.FLineWidthUpFloatValue}\r\n下限:{model.FLineWidthBaseValue - model.FLineWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.MGridIntervalValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.MGridIntervalBaseValue + model.MGridIntervalUpFloatValue}\r\n下限:{model.MGridIntervalBaseValue - model.MGridIntervalDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.MGridWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.MGridWidthBaseValue + model.MGridWidthUpFloatValue}\r\n下限:{model.MGridWidthBaseValue - model.MGridWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.MGridSpreadValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.MGridSpreadBaseValue + model.MGridSpreadUpFloatValue}\r\n下限:{model.MGridSpreadBaseValue - model.MGridSpreadDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.FGridSpreadValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.FGridSpreadBaseValue + model.FGridSpreadUpFloatValue}\r\n下限:{model.FGridSpreadBaseValue - model.FGridSpreadDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.BackPoleWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.BackPoleWidthBaseValue + model.BackPoleWidthUpFloatValue}\r\n下限:{model.BackPoleWidthBaseValue - model.BackPoleWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.MGridLengthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.MGridLengthBaseValue + model.MGridLengthUpFloatValue}\r\n下限:{model.MGridLengthBaseValue - model.MGridLengthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.MarkXDisValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.MarkXDisBaseValue + model.MarkXDisUpFloatValue}\r\n下限:{model.MarkXDisBaseValue - model.MarkXDisDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.MarkYDisValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.MarkYDisBaseValue + model.MarkYDisUpFloatValue}\r\n下限:{model.MarkYDisBaseValue - model.MarkYDisDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.ForkLengthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.ForkLengthBaseValue + model.ForkLengthBaseValue}\r\n下限:{model.ForkLengthBaseValue - model.ForkLengthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.ForkWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.ForkWidthBaseValue + model.ForkWidthUpFloatValue}\r\n下限:{model.ForkWidthBaseValue - model.ForkWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.ForkDisValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.ForkDisBaseValue + model.ForkDisUpFloatValue}\r\n下限:{model.ForkDisBaseValue - model.ForkDisDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.ChilopodLengthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.ChilopodLengthBaseValue + model.ChilopodLengthUpFloatValue}\r\n下限:{model.ChilopodLengthBaseValue - model.ChilopodLengthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.ChilopodWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.ChilopodWidthBaseValue + model.ChilopodWidthUpFloatValue}\r\n下限:{model.ChilopodWidthBaseValue - model.ChilopodWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.ShardingDisValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.ShardingDisBaseValue + model.ShardingDisUpFloatValue}\r\n下限:{model.ShardingDisBaseValue - model.ShardingDisDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.WeldingSpotDisValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.WeldingSpotDisBaseValue + model.WeldingSpotDisUpFloatValue}\r\n下限:{model.WeldingSpotDisBaseValue - model.WeldingSpotDisDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.WeldingSpotLengthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.WeldingSpotLengthBaseValue + model.WeldingSpotLengthUpFloatValue}\r\n下限:{model.WeldingSpotLengthBaseValue - model.WeldingSpotLengthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;
                                        case PrintDataEnum.WeldingSpotWidthValueLimit:
                                            if (model != null)
                                                value = $"上限:{model.WeldingSpotWidthBaseValue + model.WeldingSpotWidthUpFloatValue}\r\n下限:{model.WeldingSpotWidthBaseValue - model.WeldingSpotWidthDownFloatValue}";
                                            else
                                                value = "No Find";
                                            break;

                                        case PrintDataEnum.DefectCount:
                                            value = order.DefectCount.ToString();
                                            break;
                                        case PrintDataEnum.DKCount:
                                            value = order.DKCount.ToString();
                                            break;
                                        case PrintDataEnum.ZWCount:
                                            value = order.ZWCount.ToString();
                                            break;
                                        case PrintDataEnum.GSYCCount:
                                            value = order.GSYCCount.ToString();
                                            break;
                                        case PrintDataEnum.XWSCount:
                                            value = order.XWSCount.ToString();
                                            break;
                                        case PrintDataEnum.QKCount:
                                            value = order.QKCount.ToString();
                                            break;
                                        case PrintDataEnum.ZKCount:
                                            value = order.ZKCount.ToString();
                                            break;
                                        case PrintDataEnum.PPCount:
                                            value = order.PPCount.ToString();
                                            break;
                                        case PrintDataEnum.HSCount:
                                            value = order.HSCount.ToString();
                                            break;
                                        case PrintDataEnum.YXCount:
                                            value = order.YXCount.ToString();
                                            break;
                                        case PrintDataEnum.XBCount:
                                            value = order.XBCount.ToString();
                                            break;
                                        case PrintDataEnum.SXCount:
                                            value = order.SXCount.ToString();
                                            break;
                                        case PrintDataEnum.DSCount:
                                            value = order.DSCount.ToString();
                                            break;
                                        case PrintDataEnum.GSDLCount:
                                            value = order.GSDLCount.ToString();
                                            break;
                                        case PrintDataEnum.CJDKCount:
                                            value = order.CJDKCount.ToString();
                                            break;
                                    }
                                    break;
                                }

                            }
                            printData.Add(item.Key, value);
                        }
                    }
                }
                if ((ret)&& (printerType == PrinterType.Label))
                {
                    if (data != null)
                        if (!printControl.BarTenderSetData(printData))
                            ret = false;
      
                    if (!printControl.BarTenderPrint(printerName))
                        ret = false;  
                }
                else if ((ret) && (printerType == PrinterType.Excel))
                {
                    //只是要sheet1
                    printControl.ExcelSelectSheet(1);
                    if (data != null)
                        if (!printControl.ExcelSetDataValue(printData))
                            ret = false;
 
                    if (!printControl.ExcelPrintData(printerName))
                        ret = false;             
                }
            }
            catch (Exception ex)
            {
                Log("标签打印", $"打印失败: {ex.Message}", WarningEnum.Low);
                ret = false;
            }
            return ret;
        }

        public bool PrintFileData(PrinterType printerType, string printerName, string printerTemp, List<PrintInfo> data, Product model)
        {
            bool ret = true;
            try
            {
                //Log("标签打印", $"打印机:{printerName}, 模板路径={printerTemp}");
                if (printerType == PrinterType.Label)
                {
                    if (!printControl.BarTenderOpenFile(printerTemp))
                        ret = false;
                }
                else if (printerType == PrinterType.Excel)
                {
                    if (!printControl.ExcelOpenFile(printerTemp))
                        ret = false;
                }
                Dictionary<string, string> printData = new Dictionary<string, string>();
                if (ret)
                {
                    if (data != null)
                    {
                        foreach (var item in data)
                        {
                            string value = "";
                            //List<string> printCodes = new List<string>();

                            ////获取所有code代码
                            //foreach (var s in System.Enum.GetValues(typeof(PrintDataPdtEnum)))
                            //{
                            //    PrintDataPdtEnum dataEnum = (PrintDataPdtEnum)s;
                            //    printCodes.Add(dataEnum.GetDescription());
                            //}
                            //string[] defectCodes = new string[]
                            //{
                            //    "ExcelDefectCount","ExcelDKCount","ExcelZWCount","ExcelGSYCCount","ExcelXWSCount","ExcelQKCount",
                            //    "ExcelZKCount","ExcelPPCount","ExcelHSCount", "ExcelYXCount","ExcelXBCount","ExcelSXCount",
                            //    "LabelDefectCount","LabelDKCount","LabelZWCount","LabelGSYCCount","LabelXWSCount","LabelQKCount",
                            //    "LabelZKCount","LabelPPCount","LabelHSCount","LabelYXCount","LabelXBCount","LabelSXCount"
                            //};
                            //printCodes.AddRange(defectCodes);

                            //直接添加数据
                            if((printerType == PrinterType.Label)&& item.Type == 1 && item.IsValue) //标签数据
                            {
                                if (printData.ContainsKey(item.PrintKey))
                                    printData.Remove(item.PrintKey);
                                printData.Add(item.PrintKey, item.PrintCode);
                            }
                            else if((printerType == PrinterType.Excel) && item.Type == 0 && item.IsValue) //excel数据
                            {
                                if (printData.ContainsKey(item.PrintKey))
                                    printData.Remove(item.PrintKey);
                                printData.Add(item.PrintKey, item.PrintCode);
                            }
                            else if ((printerType == PrinterType.Label) && item.Type == 1 && !item.IsValue) //标签Code
                            {
                                switch (item.PrintCode)
                                {
                                    case "料号批次":
                                        value = order.BatchId;
                                        break;
                                    case "外观比对":
                                        value = order.CompareResult == 0 ? "未比对" : order.CompareResult == 1 ? "OK" : "NG";
                                        break;
                                    case "检测结果":
                                        value = order.Qualified ? "合格" : "不合格";
                                        break;
                                    case "料号":
                                        value = order.OrderCode;
                                        break;
                                    case "料号名称":
                                        if (model != null)
                                            value = model.Name;
                                        else
                                            value = "No Find";
                                        break;
                                    case "网版编码":
                                        value = order.SN;
                                        break;
                                    case "检测单号":
                                        value = order.DetectOrder;
                                        break;
                                    case "检测时间":
                                        value = order.CreateTime.ToString("yyyy/MM/dd HH:mm");
                                        break;
                                    case "操作员":
                                        value = userMgr.LoginUser.Name;
                                        break;

                                    
                                    case "LabelDefectCount":
                                        value = order.DefectCount.ToString();
                                        break;
                                    case "LabelDKCount":
                                        value = order.DKCount.ToString();
                                        break;
                                    case "LabelZWCount":
                                        value = order.ZWCount.ToString();
                                        break;
                                    case "LabelGSYCCount":
                                        value = order.GSYCCount.ToString();
                                        break;
                                    case "LabelXWSCount":
                                        value = order.XWSCount.ToString();
                                        break;
                                    case "LabelQKCount":
                                        value = order.QKCount.ToString();
                                        break;
                                    case "LabelZKCount":
                                        value = order.ZKCount.ToString();
                                        break;
                                    case "LabelPPCount":
                                        value = order.PPCount.ToString();
                                        break;
                                    case "LabelHSCount":
                                        value = order.HSCount.ToString();
                                        break;
                                    case "LabelYXCount":
                                        value = order.YXCount.ToString();
                                        break;
                                    case "LabelXBCount":
                                        value = order.XBCount.ToString();
                                        break;
                                    case "LabelSXCount":
                                        value = order.SXCount.ToString();
                                        break;
                                    case "LabelDSCount":
                                        value = order.DSCount.ToString();
                                        break;
                                    case "LabelGSDLCount":
                                        value = order.GSDLCount.ToString();
                                        break;
                                    case "LabelCJDKCount":
                                        value = order.CJDKCount.ToString();
                                        break;
                                }
                                if (printData.ContainsKey(item.PrintKey))
                                    printData.Remove(item.PrintKey);
                                printData.Add(item.PrintKey, item.PrintCode);
                            }
                            else if ((printerType == PrinterType.Excel) && item.Type == 0 && !item.IsValue) //excel Code
                            {
                                switch (item.PrintCode)
                                {
                                    case "料号批次":
                                        value = order.BatchId;
                                        break;
                                    case "外观比对":
                                        value = order.CompareResult == 0 ? "未比对" : order.CompareResult == 1 ? "OK" : "NG";
                                        break;
                                    case "检测结果":
                                        value = order.Qualified ? "合格" : "不合格";
                                        break;
                                    case "料号":
                                        value = order.OrderCode;
                                        break;
                                    case "料号名称":
                                        if (model != null)
                                            value = model.Name;
                                        else
                                            value = "No Find";
                                        break;
                                    case "网版编码":
                                        value = order.SN;
                                        break;
                                    case "检测单号":
                                        value = order.DetectOrder;
                                        break;
                                    case "检测时间":
                                        value = order.CreateTime.ToString("yyyy/MM/dd HH:mm");
                                        break;
                                    case "操作员":
                                        value = userMgr.LoginUser.Name;
                                        break;

                                    #region 缺陷信息
                                    case "ExcelDefectCount":
                                        value = order.DefectCount.ToString();
                                        break;
                                    case "ExcelDKCount":
                                        value = order.DKCount.ToString();
                                        break;
                                    case "ExcelZWCount":
                                        value = order.ZWCount.ToString();
                                        break;
                                    case "ExcelGSYCCount":
                                        value = order.GSYCCount.ToString();
                                        break;
                                    case "ExcelXWSCount":
                                        value = order.XWSCount.ToString();
                                        break;
                                    case "ExcelQKCount":
                                        value = order.QKCount.ToString();
                                        break;
                                    case "ExcelZKCount":
                                        value = order.ZKCount.ToString();
                                        break;
                                    case "ExcelPPCount":
                                        value = order.PPCount.ToString();
                                        break;
                                    case "ExcelHSCount":
                                        value = order.HSCount.ToString();
                                        break;
                                    case "ExcelYXCount":
                                        value = order.YXCount.ToString();
                                        break;
                                    case "ExcelXBCount":
                                        value = order.XBCount.ToString();
                                        break;
                                    case "ExcelSXCount":
                                        value = order.SXCount.ToString();
                                        break;
                                    case "ExcelDSCount":
                                        value = order.DSCount.ToString();
                                        break;
                                    case "ExcelGSDLCount":
                                        value = order.GSDLCount.ToString();
                                        break;
                                    case "ExcelCJDKCount":
                                        value = order.CJDKCount.ToString();
                                        break;
                                    #endregion
                                }
                                if (printData.ContainsKey(item.PrintKey))
                                    printData.Remove(item.PrintKey);
                                printData.Add(item.PrintKey, item.PrintCode);
                                
                            }

                           
                        }
                    }
                }
                if ((ret) && (printerType == PrinterType.Label))
                {
                    if (data != null)
                        if (!printControl.BarTenderSetData(printData))
                            ret = false;

                    if (!printControl.BarTenderPrint(printerName))
                        ret = false;
                }
                else if ((ret) && (printerType == PrinterType.Excel))
                {
                    //只是要sheet1
                    printControl.ExcelSelectSheet(1);
                    if (data != null)
                        if (!printControl.ExcelSetDataValue(printData))
                            ret = false;

                    if (!printControl.ExcelPrintData(printerName))
                        ret = false;
                }
            }
            catch (Exception ex)
            {
                Log("标签打印", $"打印失败: {ex.Message}", WarningEnum.Low);
                ret = false;
            }
            return ret;
        }
        public bool PrintFileOrderData(string printerName, string printerTemp, List<PrintInfo> data, Product model)
        {
            bool ret = true;
            try
            {
                if (!printControl.ExcelOpenFile(printerTemp))
                    ret = false;
                
                Dictionary<string, string> printData = new Dictionary<string, string>();
                if (ret)
                {
                    if (data != null)
                    {
                        foreach (var item in data)
                        {
                            string value = "";
                            //直接添加数据
                            if (item.Type == 3 && item.IsValue) //excel数据
                            {
                                if(!printData.ContainsKey(item.PrintKey))
                                    printData.Add(item.PrintKey, item.PrintCode);
                                else
                                {
                                    printData.Remove(item.PrintKey);
                                    printData.Add(item.PrintKey, item.PrintCode);
                                }
                            }
                            else if ( item.Type == 3 && !item.IsValue) //excel Code
                            {
                                switch (item.PrintCode)
                                {
                                    case "料号批次":
                                        value = order.BatchId;
                                        break;
                                    case "外观比对":
                                        if(CurrDefectOrders != null)
                                        {
                                            value = CurrDefectOrders.Exists(t => t.CompareResult == 2) ? "不通过" : "通过";
                                        }
                                        break;
                                    case "检测结果":
                                        if (CurrDefectOrders != null)
                                        {
                                            value = CurrDefectOrders.Exists(t => t.Qualified == false) ? "不合格" : "合格";
                                        }
                                        //value = order.Qualified ? "合格" : "不合格";
                                        break;
                                    case "检测数量":
                                        value = TotalCnt.ToString();
                                        break;
                                    case "合格数量":
                                        if (CurrDefectOrders != null)
                                        {
                                            value = CurrDefectOrders.FindAll(t => t.Qualified == true).Count.ToString();
                                        }
                                        break;
                                    case "不合格数量":
                                        if (CurrDefectOrders != null)
                                        {
                                            value = CurrDefectOrders.FindAll(t => t.Qualified == false).Count.ToString();
                                        }
                                        break;
                                    case "料号":
                                        value = order.OrderCode;
                                        break;
                                    case "料号名称":
                                        if (model != null)
                                            value = model.Name;
                                        else
                                            value = "No Find";
                                        break;
                                    case "网版编码":
                                        value = order.SN;
                                        break;
                                    case "检测单号":
                                        value = order.DetectOrder;
                                        break;
                                    case "检测时间":
                                        value = order.CreateTime.ToString("yyyy/MM/dd HH:mm");
                                        break;
                                    case "检测日期":
                                        value = order.CreateTime.ToString("yyyy/MM/dd");
                                        break;
                                    case "操作员":
                                        value = userMgr.LoginUser.Name;
                                        break;
                                    case "综合":
                                        if (CurrDefectOrders != null)
                                        {
                                            List<SizeDefectInfo> frt = new List<SizeDefectInfo>();
                                            for (int i = 0; i < CurrDefectOrders.Count; i++)
                                            {
                                                //获取当前步骤的均值结果
                                                var tyy = CurrDefectOrders[i].SizeDefectInfoList.FindAll(t => (t.StepName == item.PrintName && t.isAverage == true));
                                                if (tyy != null && tyy.Count > 0)
                                                    frt.AddRange(tyy);
                                            }
                                            value = frt.Exists(t => t.result == 2) ? "不合格" : "合格";
                                        }
                                        break;

                                    #region 缺陷信息
                                    case "ExcelDefectCount":
                                        value = order.DefectCount.ToString();
                                        break;
                                    case "ExcelDKCount":
                                        value = order.DKCount.ToString();
                                        break;
                                    case "ExcelZWCount":
                                        value = order.ZWCount.ToString();
                                        break;
                                    case "ExcelGSYCCount":
                                        value = order.GSYCCount.ToString();
                                        break;
                                    case "ExcelXWSCount":
                                        value = order.XWSCount.ToString();
                                        break;
                                    case "ExcelQKCount":
                                        value = order.QKCount.ToString();
                                        break;
                                    case "ExcelZKCount":
                                        value = order.ZKCount.ToString();
                                        break;
                                    case "ExcelPPCount":
                                        value = order.PPCount.ToString();
                                        break;
                                    case "ExcelHSCount":
                                        value = order.HSCount.ToString();
                                        break;
                                    case "ExcelYXCount":
                                        value = order.YXCount.ToString();
                                        break;
                                    case "ExcelXBCount":
                                        value = order.XBCount.ToString();
                                        break;
                                    case "ExcelSXCount":
                                        value = order.SXCount.ToString();
                                        break;
                                    case "ExcelDSCount":
                                        value = order.DSCount.ToString();
                                        break;
                                    case "ExcelGSDLCount":
                                        value = order.GSDLCount.ToString();
                                        break;
                                    case "ExcelCJDKCount":
                                        value = order.CJDKCount.ToString();
                                        break;
                                        #endregion
                                }
                                if (!printData.ContainsKey(item.PrintKey))
                                    printData.Add(item.PrintKey, value);
                            }


                        }
                    }
                }
                //只是要sheet1
                printControl.ExcelSelectSheet(1);
                if (data != null)
                    if (!printControl.ExcelSetDataValue(printData))
                        ret = false;

                if (!printControl.ExcelPrintData(printerName))
                    ret = false;
                
            }
            catch (Exception ex)
            {
                Log("标签打印", $"打印失败: {ex.Message}", WarningEnum.Low);
                ret = false;
            }
            return ret;
        }
        #endregion

        #region 获取Mes上传数据
        private string GetMesString(string mesJsonTemp, Product model, bool isNewStep)
        {
            string jsonData = "";
            string txt = "";
            try
            {
                var fileDir = mesJsonTemp;

                byte[] allBytes = null;

                byte[] buffer = new byte[1024];//一个1K的缓冲字节容器
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Restart();
                using (MemoryStream ms = new MemoryStream())
                {
                    using (FileStream fs = new FileStream(fileDir, FileMode.Open, FileAccess.Read))
                    {
                        int positon = 0;
                        while ((positon = fs.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            ms.Write(buffer, 0, positon);

                        }
                        allBytes = ms.ToArray();
                    }
                }
                stopwatch.Stop();

                if (null != allBytes)
                {
                    //尝试将字节转成字符串
                    txt = System.Text.Encoding.UTF8.GetString(allBytes);
                    // this.richTextBox_Result.Text = txt;

                }
                //string[] txtToArray = txt.Split('\r');
                //解析格式
                if (!string.IsNullOrEmpty(txt))
                {
                    Type t = typeof(MesCodeEnum);
                    FieldInfo[] fieldInfos = t.GetFields();
                    foreach (var item in fieldInfos)
                    {
                        if (item.FieldType.IsEnum)
                        {
                            switch ((MesCodeEnum)t.InvokeMember(item.Name, BindingFlags.GetField, null, null, null))
                            {
                                case MesCodeEnum.MM0001:
                                    txt = txt.Replace(item.Name, order.DetectOrder);
                                    break;
                                case MesCodeEnum.MM0002:
                                    txt = txt.Replace(item.Name, order.OrderCode);
                                    break;
                                case MesCodeEnum.MM0003:
                                    txt = txt.Replace(item.Name, model.Name);
                                    break;
                                case MesCodeEnum.MM0004:
                                    txt = txt.Replace(item.Name, order.SN);
                                    break;
                                case MesCodeEnum.MM0005:
                                    txt = txt.Replace(item.Name, userMgr.LoginUser.Name);
                                    break;
                                case MesCodeEnum.MM0006:
                                    txt = txt.Replace(item.Name, order.CreateTime.ToString("yyyy/MM/dd HH:mm"));
                                    break;
                                case MesCodeEnum.MM0007:
                                    txt = txt.Replace(item.Name, order.BatchId);
                                    break;
                                case MesCodeEnum.MM0008:
                                    txt = txt.Replace(item.Name, order.CompareResult == 0 ? "未比对" : order.CompareResult == 1 ? "OK" : "NG");
                                    break;
                                case MesCodeEnum.MM0009:
                                    txt = txt.Replace(item.Name, order.Qualified ? "合格" : "不合格");
                                    break;
                                case MesCodeEnum.MM0010:
                                    txt = txt.Replace(item.Name, order.TensionValue.ToString("0.000"));
                                    break;
                                case MesCodeEnum.MM0011:
                                    txt = txt.Replace(item.Name, order.HeightValue.ToString("0.000"));
                                    break;
                                case MesCodeEnum.MM0012:
                                    txt = txt.Replace(item.Name, order.LineWidthValue.ToString("0.000"));
                                    break;
                                case MesCodeEnum.MM0013:
                                    txt = txt.Replace(item.Name, order.PTValue.ToString("0.0000"));
                                    break;
                                case MesCodeEnum.MM0014:
                                    txt = txt.Replace(item.Name, order.XPTValue.ToString("0.0000"));
                                    break;

                                case MesCodeEnum.MALL000:
                                    txt = txt.Replace(item.Name, order.DefectCount.ToString());
                                    break;
                                case MesCodeEnum.MDK000:
                                    txt = txt.Replace(item.Name, order.DKCount.ToString());
                                    break;
                                case MesCodeEnum.MZW000:
                                    txt = txt.Replace(item.Name, order.ZWCount.ToString());
                                    break;
                                case MesCodeEnum.MGSYC000:
                                    txt = txt.Replace(item.Name, order.GSYCCount.ToString());
                                    break;
                                case MesCodeEnum.MQWS000:
                                    txt = txt.Replace(item.Name, order.XWSCount.ToString());
                                    break;
                                case MesCodeEnum.MQK000:
                                    txt = txt.Replace(item.Name, order.QKCount.ToString());
                                    break;
                                case MesCodeEnum.MZK000:
                                    txt = txt.Replace(item.Name, order.ZKCount.ToString());
                                    break;
                                case MesCodeEnum.MPP000:
                                    txt = txt.Replace(item.Name, order.PPCount.ToString());
                                    break;
                                case MesCodeEnum.MHS000:
                                    txt = txt.Replace(item.Name, order.HSCount.ToString());
                                    break;
                                case MesCodeEnum.MYX000:
                                    txt = txt.Replace(item.Name, order.YXCount.ToString());
                                    break;
                                case MesCodeEnum.MXB000:
                                    txt = txt.Replace(item.Name, order.XBCount.ToString());
                                    break;
                                case MesCodeEnum.MSX000:
                                    txt = txt.Replace(item.Name, order.SXCount.ToString());
                                    break;
                            }
                        }
                    }
                }
                //单点数据
                if (!string.IsNullOrEmpty(txt))
                {
                    if (!isNewStep)
                    {
                        txt = txt.Replace("MTV001", order.Tension1.ToString("0.000"));
                        txt = txt.Replace("MTV002", order.Tension2.ToString("0.000"));
                        txt = txt.Replace("MTV003", order.Tension3.ToString("0.000"));
                        txt = txt.Replace("MTV004", order.Tension4.ToString("0.000"));
                        txt = txt.Replace("MTV005", order.Tension5.ToString("0.000"));

                        txt = txt.Replace("MHV001", order.Height1.ToString("0.000"));
                        txt = txt.Replace("MHV002", order.Height2.ToString("0.000"));
                        txt = txt.Replace("MHV003", order.Height3.ToString("0.000"));
                        txt = txt.Replace("MHV004", order.Height4.ToString("0.000"));
                        txt = txt.Replace("MHV005", order.Height5.ToString("0.000"));

                        txt = txt.Replace("MYPTV001", order.PT1.ToString("0.0000"));
                        txt = txt.Replace("MYPTV002", order.PT2.ToString("0.0000"));
                        txt = txt.Replace("MYPTV003", order.PT3.ToString("0.0000"));
                        txt = txt.Replace("MYPTV004", order.PT5.ToString("0.0000"));
                        txt = txt.Replace("MYPTV005", order.PT6.ToString("0.0000"));

                        txt = txt.Replace("MLWV001", order.LineWidth1.ToString("0.000"));
                        txt = txt.Replace("MLWV002", order.LineWidth2.ToString("0.000"));
                        txt = txt.Replace("MLWV003", order.LineWidth3.ToString("0.000"));
                        txt = txt.Replace("MLWV004", order.LineWidth4.ToString("0.000"));
                        txt = txt.Replace("MLWV005", order.LineWidth5.ToString("0.000"));
                        txt = txt.Replace("MLWV006", order.LineWidth6.ToString("0.000"));
                        txt = txt.Replace("MLWV007", order.LineWidth7.ToString("0.000"));
                        txt = txt.Replace("MLWV008", order.LineWidth8.ToString("0.000"));
                        txt = txt.Replace("MLWV009", order.LineWidth9.ToString("0.000"));
                    }
                    else
                    {
                        string[] pointType = new string[11] {"Tension", "Height", "Y轴方向PT值检测" , "线宽正面" , "反面检测" ,
                                "X轴方向PT值检测","主栅连接线检测","主栅宽度检测","主栅间距","细栅间距检测","背极宽度"};
                        string[] codeType = new string[11] {"MTV00", "MHV00", "MYPTV00" , "MLWV00" , "MLWV00" ,
                                "MXPTV00","MTV00","MTV00","MTV00","MTV00","MTV00"};
                        for (int i = 0; i < pointType.Length; i++)
                        {
                            List<SizeDefectInfo> t1 = order.SizeDefectInfoList.Where(q => q.PointCode == pointType[i]).ToList();
                            for (int j = 0; j < t1.Count; j++)
                            {
                                txt = txt.Replace(codeType[i] + (i + 1).ToString(), t1[j].Data.ToString("0.0000"));
                            }
                        }
                        
                    }
                }
            }
            catch (Exception ex) {
                Log("MES数据解析", "解析错误:" + ex.Message, WarningEnum.High);
            }
            jsonData = txt;

            return jsonData;
        }
        #endregion

        #region 缺陷分布
        public bool GetDefectDistribution(out string imagePath, out Order outOrder)
        {
            bool ret = false;
            imagePath = "";
            outOrder = null;
            if (CurrProductModel == null || order == null || order.DefectInfoList == null || order.DefectInfoList.Count < 1)
            {
                Log("缺陷分布", "无数据", WarningEnum.Low);
                return false;
            }
            //图纸
            try
            {
                string gbxBmpPath = "";
                var attachmentFile = CurrProductModel.AttachmentList.FirstOrDefault(x => x.Type == 0);
                if (attachmentFile != null)
                {
                    gbxBmpPath = confMgr.ProjectDir + $"\\{attachmentFile.NameTimestamp}";
                    if (!File.Exists(gbxBmpPath + ".bmp")) 
                        gbxBmpPath = "";
                }
                if (string.IsNullOrEmpty(gbxBmpPath))
                {
                    Log("缺陷分布", "图纸文件不存在!", WarningEnum.Low);
                    MessageBox.Show("图纸文件不存在！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return false;
                }
                if (!File.Exists(gbxBmpPath + ".jpg"))//转背景后的图纸文件
                {
                    //换背景JPG
                    Mat mat = Cv2.ImRead(gbxBmpPath + ".bmp");
                    Cv2.CvtColor(mat, mat, ColorConversionCodes.RGB2GRAY);//转灰度图
                    for (int i = 0; i < mat.Height; i++)
                    {
                        for (int j = 0; j < mat.Width; j++)
                        {
                            if (mat.At<byte>(i, j) == 255)//白色 
                                mat.Set<byte>(i, j, 0);
                            else
                                mat.Set<byte>(i, j, 255);
                        }
                    }
     
                    OpenCvSharp.Extensions.BitmapConverter.ToBitmap(mat).Save(gbxBmpPath + ".jpg", ImageFormat.Jpeg);
                }
                imagePath = gbxBmpPath + ".jpg";
                outOrder = order;
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "异常", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
            }
            return ret;
        }
        #endregion

        #region 尺寸缺陷禁用
        public void SetSizeEnable(bool val)
        {
            SizeEnable = val;
            Log("尺寸检测", val?"尺寸启用":"尺寸禁用");
        }
        public void SetDefectEnable(bool val)
        {
            DefectEnable = val;
            Log("缺陷检测", val ? "缺陷启用" : "缺陷禁用");
        }
        #endregion

        #region 打印队列
        private void PrintDataList(string processName, TensionProp TensionParam, double baseValue, double upLimit, double loLimit)
        {
            try
            {
                if (TensionParam.OpenPrint)
                {
                    if (!string.IsNullOrEmpty(TensionParam.ExcelData))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 0,
                            IsValue = true,
                            PrintKey = TensionParam.ExcelData,
                            PrintCode = order.TensionValue.ToString("0.00"),
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(TensionParam.ExcelLimit))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 0,
                            IsValue = true,
                            PrintKey = TensionParam.ExcelLimit,
                            PrintCode = ((TensionParam.OpenUseLimit)&&(TensionParam.MaxLimit + TensionParam.MinLimit>0)&&
                            (TensionParam.MaxLimit == TensionParam .MinLimit))? $"{TensionParam.StandardValues}±{TensionParam.MaxLimit}":
                            $"上限：{baseValue+ upLimit}\r\n下限:{baseValue-loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
                if (TensionParam.OpenPrintLabel)
                {
                    if (!string.IsNullOrEmpty(TensionParam.ExcelData))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 1,
                            IsValue = true,
                            PrintKey = TensionParam.ExcelData,
                            PrintCode = order.TensionValue.ToString("0.00"),
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(TensionParam.ExcelLimit))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 1,
                            IsValue = true,
                            PrintKey = TensionParam.ExcelLimit,
                            PrintCode = ((TensionParam.OpenUseLimit) && (TensionParam.MaxLimit + TensionParam.MinLimit > 0) &&
                            (TensionParam.MaxLimit == TensionParam.MinLimit)) ? $"{TensionParam.StandardValues}±{TensionParam.MaxLimit}" :
                            $"上限：{baseValue + upLimit}\r\n下限:{baseValue - loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
                if (TensionParam.OpenPrintOrder)
                {
                    if (!string.IsNullOrEmpty(TensionParam.OrderData))
                        if (CurrDefectIndex < TensionParam.OrderData.Split(',').Length)
                        {
                            CurrOrderPrintInfos.Add(new PrintInfo()
                            {
                                Type = 3,
                                IsValue = true,
                                PrintKey = TensionParam.OrderData.Split(',')[CurrDefectIndex],
                                PrintCode = order.TensionValue.ToString("0.00"),
                                CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                            });
                        }
                    if (!string.IsNullOrEmpty(TensionParam.OrderLimit))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = true,
                            PrintKey = TensionParam.OrderLimit,
                            PrintCode = ((TensionParam.OpenUseLimit) && (TensionParam.MaxLimit + TensionParam.MinLimit > 0) &&
                            (TensionParam.MaxLimit == TensionParam.MinLimit)) ? $"{TensionParam.StandardValues}±{TensionParam.MaxLimit}" :
                            $"上限：{baseValue + upLimit}\r\n下限:{baseValue - loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(TensionParam.OrderTestName))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = true,
                            PrintKey = TensionParam.OrderTestName,
                            PrintCode = processName,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(TensionParam.OrderTestResult))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = false,
                            PrintKey = TensionParam.OrderTestResult,
                            PrintCode = "综合",
                            PrintName = processName,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"打印参数错误:{ex.Message}");
            }
        }
        private void PrintDataList(string processName, ThicknessProp ThicknessParam, double baseValue, double upLimit, double loLimit)
        {
            try
            {
                if (ThicknessParam.OpenPrint)
                {
                    if (!string.IsNullOrEmpty(ThicknessParam.ExcelData))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 0,
                            IsValue = true,
                            PrintKey = ThicknessParam.ExcelData,
                            PrintCode = order.HeightValue.ToString("0.00"),
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(ThicknessParam.ExcelLimit))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 0,
                            IsValue = true,
                            PrintKey = ThicknessParam.ExcelLimit,
                            PrintCode = ((ThicknessParam.OpenUseLimit) && (ThicknessParam.MaxLimit + ThicknessParam.MinLimit > 0) &&
                            (ThicknessParam.MaxLimit == ThicknessParam.MinLimit)) ? $"{ThicknessParam.StandardValues}±{ThicknessParam.MaxLimit}" :
                            $"上限：{baseValue + upLimit}\r\n下限:{baseValue - loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
                if (ThicknessParam.OpenPrintLabel)
                {
                    if (!string.IsNullOrEmpty(ThicknessParam.ExcelData))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 1,
                            IsValue = true,
                            PrintKey = ThicknessParam.ExcelData,
                            PrintCode = order.HeightValue.ToString("0.00"),
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(ThicknessParam.ExcelLimit))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 1,
                            IsValue = true,
                            PrintKey = ThicknessParam.ExcelLimit,
                            PrintCode = ((ThicknessParam.OpenUseLimit) && (ThicknessParam.MaxLimit + ThicknessParam.MinLimit > 0) &&
                            (ThicknessParam.MaxLimit == ThicknessParam.MinLimit)) ? $"{ThicknessParam.StandardValues}±{ThicknessParam.MaxLimit}" :
                            $"上限：{baseValue + upLimit}\r\n下限:{baseValue - loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
                if (ThicknessParam.OpenPrintOrder)
                {
                    if (!string.IsNullOrEmpty(ThicknessParam.OrderData))
                        if (CurrDefectIndex < ThicknessParam.OrderData.Split(',').Length)
                            CurrOrderPrintInfos.Add(new PrintInfo()
                            {
                                Type = 3,
                                IsValue = true,
                                PrintKey = ThicknessParam.OrderData.Split(',')[CurrDefectIndex],
                                PrintCode = order.HeightValue.ToString("0.00"),
                                CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                            });
                    if (!string.IsNullOrEmpty(ThicknessParam.OrderLimit))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = true,
                            PrintKey = ThicknessParam.OrderLimit,
                            PrintCode = ((ThicknessParam.OpenUseLimit) && (ThicknessParam.MaxLimit + ThicknessParam.MinLimit > 0) &&
                            (ThicknessParam.MaxLimit == ThicknessParam.MinLimit)) ? $"{ThicknessParam.StandardValues}±{ThicknessParam.MaxLimit}" :
                            $"上限：{baseValue + upLimit}\r\n下限:{baseValue - loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(ThicknessParam.OrderTestName))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = true,
                            PrintKey = ThicknessParam.OrderTestName,
                            PrintCode = processName,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(ThicknessParam.OrderTestResult))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = false,
                            PrintKey = ThicknessParam.OrderTestResult,
                            PrintCode = "综合",
                            PrintName = processName,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"打印参数错误:{ex.Message}");
            }
        }
        private void PrintDataList(string processName, PointTestProp testParam, double data, double upLimit, double loLimit)
        {
            try
            {
                if (testParam.OpenPrint)
                {
                    if (!string.IsNullOrEmpty(testParam.ExcelData))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 0,
                            IsValue = true,
                            PrintKey = testParam.ExcelData,
                            PrintCode = data.ToString("0.0000"),
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(testParam.ExcelLimit))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 0,
                            IsValue = true,
                            PrintKey = testParam.ExcelLimit,
                            PrintCode = ((testParam.MaxLimit + testParam.MinLimit)>0&&(testParam.MaxLimit == testParam.MinLimit)) ? 
                            $"{testParam.StandardValues}±{testParam.MaxLimit}" : $"上限：{upLimit}\r\n下限:{loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
                if (testParam.OpenPrintLabel)
                {
                    if (!string.IsNullOrEmpty(testParam.ExcelData))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 1,
                            IsValue = true,
                            PrintKey = testParam.ExcelData,
                            PrintCode = data.ToString("0.0000"),
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(testParam.ExcelLimit))
                        CurrPrintInfos.Add(new PrintInfo()
                        {
                            Type = 1,
                            IsValue = true,
                            PrintKey = testParam.ExcelLimit,
                            PrintCode = ((testParam.MaxLimit + testParam.MinLimit) > 0 && (testParam.MaxLimit == testParam.MinLimit)) ?
                            $"{testParam.StandardValues}±{testParam.MaxLimit}" : $"上限：{upLimit}\r\n下限:{loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
                if (testParam.OpenPrintOrder)
                {
                    if (!string.IsNullOrEmpty(testParam.OrderData))
                        if (CurrDefectIndex < testParam.OrderData.Split(',').Length)
                            CurrOrderPrintInfos.Add(new PrintInfo()
                            {
                                Type = 3,
                                IsValue = true,
                                PrintKey = testParam.OrderData.Split(',')[CurrDefectIndex],
                                PrintCode = data.ToString("0.0000"),
                                CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                                ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                            });
                    if (!string.IsNullOrEmpty(testParam.OrderLimit))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = true,
                            PrintKey = testParam.OrderLimit,
                            PrintCode = ((testParam.MaxLimit + testParam.MinLimit) > 0 && (testParam.MaxLimit == testParam.MinLimit)) ?
                            $"{testParam.StandardValues}±{testParam.MaxLimit}" : $"上限：{upLimit}\r\n下限:{loLimit}",
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(testParam.OrderTestName))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = true,
                            PrintKey = testParam.OrderTestName,
                            PrintCode = processName,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                    if (!string.IsNullOrEmpty(testParam.OrderTestResult))
                        CurrOrderPrintInfos.Add(new PrintInfo()
                        {
                            Type = 3,
                            IsValue = false,
                            PrintKey = testParam.OrderTestResult,
                            PrintCode = "综合",
                            PrintName = processName,
                            CreateUserCode = SysMgr.Instance.UserMgr.LoginUser.Code,
                            ModifyUserCode = SysMgr.Instance.UserMgr.LoginUser.Code
                        });
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"打印参数错误:{ex.Message}");
            }
        }
        #endregion
    }

    #region 系统事件
    /// <summary>
    /// 流程事件
    /// </summary>
    public class RunEventArgs : EventArgs
    {
        private int _cmd;
        public int Cmd { get { return _cmd; } }

        private string _sn;
        public string SN { get { return _sn; } }

        private List<StepProcess> _stepProcesses;
        public List<StepProcess> StepProcessesList { get { return _stepProcesses; } }

        private bool _newStep;
        public bool NewStep { get { return _newStep; } }


        private int _stepIndex;
        public int StepIndex { get { return _stepIndex; } }

        private string _mesg;
        public string Mesg { get { return _mesg; } }

        private bool _compareResult;
        public bool CompareResult {  get { return _compareResult; } }

        private string _compareResultString;
        public string CompareResultString { get { return _compareResultString; } }

        private long _time;
        public long Time { get { return _time; } }
        private int _num;
        public long Num { get { return _num; } }

        private long _cnt;
        public long Cnt { get { return _cnt; } }
        public RunEventArgs(string sn, List<StepProcess> list, bool newstep = false)
        {
            this._cmd = 0;
            this._sn = sn;
            this._stepProcesses = list;
            this._newStep = newstep;
        }
        public RunEventArgs(int stepIndex)
        {
            this._cmd = 1;
            this._stepIndex = stepIndex;
        }
        public RunEventArgs(int stepIndex, string mesg)
        {
            this._cmd = 2;
            this._stepIndex = stepIndex;
            _mesg = mesg;
        }
        public RunEventArgs(int cmd, bool rel, int cnt)
        {
            this._cmd = cmd;
            this._compareResult = rel;
            this._cnt = cnt;
        }
        public RunEventArgs(int cmd, bool rel, int cnt, string rel_str)
        {
            this._cmd = cmd;
            this._compareResult = rel;
            this._cnt = cnt;
            this._compareResultString = rel_str;
        }
        public RunEventArgs(long time )
        {
            this._cmd = 7;
            this._time = time;
        }
        public RunEventArgs(long time, int num)
        {
            this._cmd = 8;
            this._time = time;
            this._num = num;
        }

        private int _picIndex;
        public int PicIndex { get { return _picIndex; } }
        private HObject _pic;
        public HObject Pic { get { return _pic; } }
        public RunEventArgs(int index, HObject pic)
        {
            this._cmd = 6;
            this._picIndex = index;
            this._pic = pic.Clone();
        }

        private bool _over;
        public bool Over { get { return _over; } }
        public RunEventArgs(bool ov)
        {
            this._cmd = 10;
            this._over = ov;
        }
        //测厚显示
        private List<double> _value;
        public List<double> Value { get { return _value; } }
        private double _value_up;
        public double Value_up { get { return _value_up; } }
        private double _value_low;
        public double Value_low { get { return _value_low; } }
        public RunEventArgs(int cmd, List<double> val, double up, double low)
        {
            this._cmd = cmd;
            this._value = val;
            this._value_up = up;
            this._value_low = low;
        }

        //新流程数据显示
        private double _value_ave;
        public double Value_ave { get { return _value_ave; } }

        private int _processSts;
        public int ProcessSts { get { return _processSts; } }

        private bool _processType;
        public bool ProcessType { get { return _processType; } }
        public RunEventArgs(int stepIndex, string mesg, List<double> val, double rel_val, double max, double min, int proRel, bool type)
        {
            this._cmd = 30;
            this._stepIndex = stepIndex;
            this._mesg = mesg;
            this._value = val;
            this._value_ave = rel_val;
            this._value_up = max;
            this._value_low = min;
            this._processSts = proRel;
            this._processType = type;
        }
        public RunEventArgs(int stepIndex, string mesg, int proRel, bool type)
        {
            this._cmd = 31;
            this._stepIndex = stepIndex;
            this._mesg = mesg;          
            this._processSts = proRel;
            this._processType = type;
        }
    }
    /// <summary>
    /// 显图事件
    /// </summary>
    public class ImgEventArgs : EventArgs
    {
        private Bitmap[] _bmps;
        public Bitmap[] Bitmaps { get { return _bmps; } }

        private Mat[] _bmps_cut;
        public Mat[] Bmps_cut { get { return _bmps_cut; } }

        private double _x;
        public double X { get { return _x; } }
        private double _y;
        public double Y { get { return _y; } }

        private List<Dictionary<int, List<string>[]>> _info;
        public List<Dictionary<int, List<string>[]>> Info
        {
            get { return _info; }
        }

        public ImgEventArgs(Bitmap[] bmps, Mat[] bmps_cut, double Xmm, double Ymm, List<Dictionary<int, List<string>[]>> info)
        {
            this._bmps = new Bitmap[bmps.Length];
            for (int i = 0; i < bmps.Length; i++)
            {
                this._bmps[i] = (Bitmap)bmps[i].Clone();
            }
            this._bmps_cut = new Mat[bmps_cut.Length];
            for (int i = 0; i < bmps_cut.Length; i++)
            {
                this._bmps_cut[i] = bmps_cut[i].Clone();
            }
            this._x = Xmm;
            this._y = Ymm;
            this._info = info;
        }      
    }
    /// <summary>
    /// 主窗体事件
    /// </summary>
    public class MainEventArgs : EventArgs
    {
        private string _tag;
        public string Tag { get { return _tag; } }

        private string _message;
        public string Message { get { return _message; } }

        private int _showIndex;
        public int ShowIndex { get { return _showIndex; } }

        private WarningEnum _warning;
        public WarningEnum Warning { get { return _warning; } }
        public MainEventArgs(int index)
        {
            this._showIndex = index;
        }
        public MainEventArgs(int index, string message)
        {
            this._message = message;
            this._showIndex = index;
        }
        public MainEventArgs(string tag, string message, WarningEnum warning =  WarningEnum.Normal)
        {
            this._tag = tag;
            this._message = message;
            this._showIndex = 0;
            this._warning = warning;
        }
    }
    /// <summary>
    /// 初始化事件
    /// </summary>
    public class InitEventArgs : EventArgs
    {
        private string _message;
        public string Message { get { return _message; } }

        private bool _isInitialized;
        public bool IsInitialized { get { return _isInitialized; } }
        public InitEventArgs()
        {

        }
        public InitEventArgs(string message, bool isInitialized = false)
        {
            this._message = message;
            this._isInitialized = isInitialized;
        }
    }
    #endregion
}