HOZ/MeasureThread/Measure.cs

//时间：20200610
//作者：郝爽
//功能：测量线程

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;
using System.IO;
using System.Drawing;
using System.Xml;

using SmartSEMControl;
using MeasureData;
using FileManager;
using WebManager;

using OpenCvSharp;
using DBManager;
using Extender;
using CookComputing.XmlRpc;

namespace MeasureThread
{
    #region 信息定义
    public delegate void ThreadStatusHandler(object sender, ThreadStatusEventArgs e);  //声明委托
    public delegate void CutHolesStatusHandler(object sender, CutHolesStatusEventArgs e);

    //测量线程状态
    public class ThreadStatusEventArgs
    {
        //状态
        public Boolean State
        {
            get { return m_state; }
            set { m_state = value; }
        }
        private Boolean m_state;
        //时间
        public DateTime Time
        {
            get { return m_time; }
            set { m_time = value; }
        }
        private DateTime m_time;
        //步骤代码
        public String Step_Code
        {
            get { return step_Code; }
            set { step_Code = value; }
        }
        private String step_Code;
        //其他消息
        public String Message
        {
            get { return this.message; }
            set { this.message = value; }
        }
        private String message;

        //孔名
        public String HoleName
        {
            get { return this.holeName; }
            set { this.holeName = value; }
        }
        private String holeName;

        //图片信息
        public class PictureInformation
        {
            public String Picture_FullPath
            {
                get { return picture_FullPath; }
                set { picture_FullPath = value; }
            }
            private String picture_FullPath;

            public double Work_Voltage
            {
                get { return work_Voltage; }
                set { work_Voltage = value; }
            }
            private double work_Voltage;

            public double Magnification
            {
                get { return magnification; }
                set { magnification = value; }
            }
            private double magnification;

            public double Work_Distance
            {
                get { return work_Distance; }
                set { work_Distance = value; }
            }
            private double work_Distance;

            public String Work_Status
            {
                get { return work_Status; }
                set { work_Status = value; }
            }
            private String work_Status;
        }
        //图片信息实例类
        public PictureInformation Picture_Information
        {
            get { return picture_Information; }
            set { picture_Information = value; }
        }
        private PictureInformation picture_Information;

        //图像处理信息
        public class ImageInformation
        {
            public int Method_Name
            {
                get { return method_Name; }
                set { method_Name = value; }
            }
            private int method_Name;

            public Source_Img_Degree_Direction SIDD;
            public Cut_Position CP;
            public Cut_Success CS;
            public Trapezoid_Top_Center_Position TTCP;
            public Auto_Foucs AF;
            public Auto_Stigmatic AS;
            public Center_Position_OffsetAngle_Direction CPOD;
            public Measure_Size MS;

            public ImageInformation()
            {
                SIDD = new Source_Img_Degree_Direction();
                CP = new Cut_Position();
                CS = new Cut_Success();
                TTCP = new Trapezoid_Top_Center_Position();
                AF = new Auto_Foucs();
                AS = new Auto_Stigmatic();
                CPOD = new Center_Position_OffsetAngle_Direction();
                MS = new Measure_Size();
            }

            //1-计算原始图像偏移角度及方向
            public class Source_Img_Degree_Direction
            {
                public Boolean Is_Image = false;

                public double Degree
                {
                    get { return degree; }
                    set { degree = value; }
                }
                private double degree;

                public int Direction
                {
                    get { return direction; }
                    set { direction = value; }
                }
                private int direction;

                public int State
                {
                    get { return state; }
                    set { state = value; }
                }
                private int state;
            }

            //2-计算切割点位置
            public class Cut_Position
            {
                public Boolean Is_Image = false;

                public double Offsetx
                {
                    get { return offsetx; }
                    set { offsetx = value; }
                }
                private double offsetx;

                public double Offsety
                {
                    get { return offsety; }
                    set { offsety = value; }
                }
                private double offsety;

                public int State
                {
                    get { return state; }
                    set { state = value; }
                }
                private int state;
            }

            //3-是否切割成功
            public class Cut_Success
            {
                public Boolean Is_Image = false;

                public int State
                {
                    get { return state; }
                    set { state = value; }
                }
                private int state;

            }

            //4-计算切割后图像梯形区域上边中心点坐标
            public class Trapezoid_Top_Center_Position
            {
                public Boolean Is_Image = false;

                public double TopCenterX
                {
                    get { return topCenterX; }
                    set { topCenterX = value; }
                }
                private double topCenterX;

                public double TopCenterY
                {
                    get { return topCenterY; }
                    set { topCenterY = value; }
                }
                private double topCenterY;

                public int State
                {
                    get { return state; }
                    set { state = value; }
                }
                private int state;
            }

            //5-自动对焦
            public class Auto_Foucs
            {
                public Boolean Is_Image = true;

                public String Img_Path
                {
                    get { return img_Path; }
                    set { img_Path = value; }
                }
                private String img_Path;
            }

            //6-自动像闪
            public class Auto_Stigmatic
            {
                public Boolean Is_Image = true;

                public String Img_Path
                {
                    get { return img_Path; }
                    set { img_Path = value; }
                }
                private String img_Path;
            }

            //7-计算切割面区域中心坐标，以及偏移角度及方向
            public class Center_Position_OffsetAngle_Direction
            {
                public Boolean Is_Image = false; 

                public double CenterX
                {
                    get { return centerX; }
                    set { centerX = value; }
                }
                private double centerX;

                public double CenterY
                {
                    get { return centerY; }
                    set { centerY = value; }
                }
                private double centerY;

                public double Degree
                {
                    get { return degree; }
                    set { degree = value; }
                }
                private double degree;

                public int Direction
                {
                    get { return direction; }
                    set { direction = value; }
                }
                private int direction;

                public int State
                {
                    get { return state; }
                    set { state = value; }
                }
                private int state;
            }

            //8-测量尺寸
            public class Measure_Size
            {
                public Boolean Is_Image = false;

                public int State
                {
                    get { return state; }
                    set { state = value; }
                }
                private int state;
            }
        }
        //图像处理信息实例类
        public ImageInformation Image_Information
        {
            get { return image_Information; }
            set { image_Information = value; }
        }
        private ImageInformation image_Information;

        public ThreadStatusEventArgs(string a_State)
        {
            picture_Information = new PictureInformation();
            image_Information = new ImageInformation();
        }
    }

    //切孔状态
    public class CutHolesStatusEventArgs
    {
        public string State
        {
            get { return m_state; }
            set { m_state = value; }
        }
        private string m_state;

        public string HoleName
        {
            get { return m_holeName; }
            set { m_holeName = value; }
        }
        private string m_holeName;

        public CutHolesStatusEventArgs(string a_state, string a_holeName)
        {
            this.m_state = a_state;
            this.m_holeName = a_holeName;
        }
    }
    #endregion

    public class Measure
    {
        NLog.Logger log;
        #region 变量定义
        //Web接口类
        public WebResult wr = null;

        //SmartSEM远程路径
        public String RemoteELYPath = "";
        public String RemoteMLFPath = "";

        //扫描周期
        private float cycle_time = 0;

        //人工干预
        public int hand_intervene = 2;

        //样品台保护值
        public float X_Min = 0;
        public float X_Max = 0.13f;
        public float Y_Min = 0;
        public float Y_Max = 0.13f;
        public float Z_Min = 0;
        public float Z_Max = 0.05f;
        public float T_Min = -4;
        public float T_Max = 70;
        public float R_Min = -380;
        public float R_Max = 380;
        public float M_Min = 0;
        public float M_Max = 0.012f;

        public event ThreadStatusHandler SendThreadStatus;  // 声明事件
        public event CutHolesStatusHandler SendCutHolesStatus;  // 声明事件

        //定义一个全局的消息类
        ThreadStatusEventArgs arg = new ThreadStatusEventArgs("0-0");

        //全局只有一个fatorySEM
        static FactoryHardware factorySEM = FactoryHardware.Instance;
        ISEMControl iSEM = factorySEM.ISEM;

        //@的作用是不用转义字符\\只打一个就行
        const String ImageName0 = @"SEMStraighten.tif"; //传给客户，原始图像，为拉直操作
        const String ImageName1 = @"FIBStraighten.tif"; //传给客户，原始图像，为拉直操作
        //const String ImageName1 = @"SEMFindCutPostion.tif"; //传给客户，作水平校正
        const String ImageName2 = @"FIBCutPostion.tif";//传给客户，找到切割点
        const String ImageName31 = @"FIBBefore.tif";
        const String ImageName32 = @"FIBAfter.tif";
        const String ImageName4 = @"SEMTrapCP.tif";//传给客户，找到已经切割点
        const String ImageName5 = @"SEMDegreeTrap.tif";//传给客户，水平校正
        const String ImageName6 = @"SEMMagEnd.tif";//传给客户，测量层高
        const String ImageName7 = @"EDSImage.tif";//计算感兴趣的区域
        const String ImageName8 = @"SEMAfterMoveToPix.tif";//精确的位置移动后的图像
        const String ImageName9 = @"SEMBeforeMoveToPix.tif";//精确的位置移动后的图像
        const String ImageName10 = @"SEMTrapCPAfter.tif";//传给客户，找到已经切割点
        const String ImageName111 = @"SEMBeforeCut.tif";//切割前SEM拍照
        const String ImageName112 = @"SEMAfterCut.tif";//切割后SEM拍照
        const String ImageNameTwo_1 = @"SEMRegion.tif";//第一个测量区域拍照
        const String ImageNameTwo_2 = @"SEMTwoRegion.tif";//第二个测量区域拍照
        const String ImageNameTwo_11 = @"SEMOneRegionMove.tif";//第一个测量区域拍照
        const String ImageNameTwo_22 = @"SEMTwoRegionMove.tif";//第二个测量区域拍照

        const String MacoInsertPt = "GIS Insert.MLF"; //传入PT针
        const String MacoRetractPt = "GIS Retract.MLF"; //退出PT针
        const String MacoScanPic = "Scan picture.MLF";//一般质量抓图的宏
        const String MacoGoodPic = "Good picture.MLF";//高质量抓图的宏
        const String MacoExportTif = "Export TIFF.MLF";// 导出有标尺的图像，这个图像为使用工具SmartSEM工具的图像

        const String ElyDeposition = @"Deposition.ely"; //沉积
        const String ElyCrossSection = @"CrossSection.ely"; //切割

        const float fMin = (float)0.0000002; //单位是米
        const float fSateyZ = (float)0.03;//单位是米

        public Boolean key_stop = false;

        String focus_path = "";
        String FIBfocus_path = "";
        String StigX_path = "";
        String StigY_path = "";
        String EDS_path = "";
        String data_path = "";

        int m_nWorkHoleNo = -1;


        //测量文件
        private MeasureFile m_measureFile;
        public MeasureFile MeasureFile
        {
            get { return this.m_measureFile; }
            set { this.m_measureFile = value; }
        }

        //测量的切割孔，这个切孔的状态要保存的测量文件中去
        private List<MeasureData.CutHole> m_cutHoles;
        public List<MeasureData.CutHole> cutHoles
        {
            get { return this.m_cutHoles; }
            set { this.m_cutHoles = value; }
        }

        //工作文件夹
        private string m_WorkingFolder;
        public string WorkingFolder
        {
            get { return this.m_WorkingFolder; }
            set { this.m_WorkingFolder = value; }
        }

        //程序当前路径
        private string m_ProgramFolder = Directory.GetCurrentDirectory();

        //线程状态
        private ThreadStatus m_ThreadStatus;
        public ThreadStatus TStatus
        {
            get { return this.m_ThreadStatus; }
            set { this.m_ThreadStatus = value; }
        }
        #endregion

        //构造函数
        public Measure(String webServerIP, String webServerPort, String webServerUrl)
        {
             log = NLog.LogManager.GetCurrentClassLogger();
            TStatus = new ThreadStatus();
            cutHoles = new List<MeasureData.CutHole>();
            //配置远程连接
            wr = new WebResult(webServerIP,webServerPort,webServerUrl);
        }

        //初始化测量业务, 读测量文件，判断是否有可测试的切孔
        public bool InitMeas(MeasureFile a_measureFile)
        {
            log.Info("进入初始化函数");
            m_measureFile = a_measureFile;
            List<CutHole> listHoles = m_measureFile.ListCutHole;

            foreach (CutHole h in listHoles)
            {
                if (h.SWITCH == true)
                {
                    m_cutHoles.Add(h);
                }
            }
            
            if (m_cutHoles.Count == 0)
                return false;

            if (m_measureFile.MParam.EDS == true)
            {
                log.Info("能谱分析", true);
                Init_MeasDB();
            }


            return true;
        }

        //给前台UI发送消息步骤
        public void SendMsg(string step_code)
        {
            arg.Step_Code = step_code;
            arg.Time = DateTime.Now;
            SendThreadStatus(this, arg);
        }

        //给前台UI发送孔状态信息
        public void SendCutHoleMsg(string a_state, string a_holeName)
        {
            CutHolesStatusEventArgs arg = new CutHolesStatusEventArgs(a_state, a_holeName);
            arg.HoleName = a_holeName;
            arg.State = a_state;
            SendCutHolesStatus(this, arg);
        }

        //测量流程
        public void DoMeasure()
        {
            //创建线程的测量状态的更新
            this.TStatus.ComputeTime(THREAD_TIME_TYPE.START);
          

            //检查硬件连接是否正常
            log.Warn("测量线程：开始连接硬件...", true);
            if (!ConnectHardware())
            {
                MessageBox.Show("连接电镜失败！","重要错误",MessageBoxButtons.OK,MessageBoxIcon.Error);
                this.TStatus.ComputeTime(THREAD_TIME_TYPE.STOPPED);
                log.Error("测量线程报错：连接硬件硬件连接失败", false);
                return;
            }

            //设置工作文件夹
            SetWorkingFolderStr();           

            //设置SmartSEM远程路径
            iSEM.SetRemoteELYPath(RemoteELYPath);
            iSEM.SetRemoteMLFPath(RemoteMLFPath);

            //增加EDS控制


            //将停止键复位
            key_stop = false;

            //开始测量就将模式设置为SEM
            log.Info("测量线程：开始切换到SEM模式", true);
            if (!iSEM.CmdFIBModeSEM())
            {
                log.Error("测量线程报错：开始切换到SEM模式失败。", false);
                return;
            }
            arg.Picture_Information.Work_Status = "SEM";

            //设置扫描周期
            log.Info("测量线程：设置电镜图像扫描周期为对焦接口程序适合的扫描周期", true);
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            if (cycle_time == 0)
            {
                log.Error("测量线程报错：获取扫描周期时间失败", false);
                return;
            }
            Thread.Sleep((int)cycle_time +100);

            //开始做各个孔的检测
            for (int i = 0; i < m_cutHoles.Count; i++)
            {
                //自动亮度对比度
                log.Info("测量线程：开启自动亮度，对比度调节", true);
                iSEM.SetAutoBright(100);
                Thread.Sleep(200);
                iSEM.SetAutoContrast(100);
                Thread.Sleep(200);
                //log.Info("SEM模式设置自动亮度调节目标50%，亮度调节目标30%", true);
                if (!iSEM.SetAutoVideoBrightnessAndContrast())
                {
                    log.Error("测量线程报错：开始设置自动亮度、对比度失败。", false);
                    return;
                }
                Thread.Sleep(5000);

                log.Warn("测量线程：测试第"+i.ToString()+"个分析点。", true);
                //记录测量序号和孔名
                m_nWorkHoleNo = i;
                arg.HoleName = m_cutHoles[i].HoleName;
                //最终数据存放目录
                data_path = WorkingFolder + "\\" + m_cutHoles[i].HoleName;
                //对焦数据存放目录
                focus_path = WorkingFolder + "\\" + m_cutHoles[i].HoleName + "\\Focus";
                m_measureFile.MParam.AutoFocus.Path = focus_path;
                if (!Directory.Exists(focus_path))
                {
                    Directory.CreateDirectory(focus_path);
                }
                //StigX数据存放目录
                StigX_path = WorkingFolder + "\\" + m_cutHoles[i].HoleName + "\\StigX";
                m_measureFile.MParam.AutoStigX.Path = StigX_path;
                if (!Directory.Exists(StigX_path))
                {
                    Directory.CreateDirectory(StigX_path);
                }
                //StigY数据存放目录
                StigY_path = WorkingFolder + "\\" + m_cutHoles[i].HoleName + "\\StigY";
                m_measureFile.MParam.AutoStigY.Path = StigY_path;
                if (!Directory.Exists(StigY_path))
                {
                    Directory.CreateDirectory(StigY_path);
                }
                //EDS数据存放路径
                if (m_measureFile.MParam.EDS == true)
                {
                    EDS_path = WorkingFolder + "\\" + m_cutHoles[i].HoleName + "\\EDS";
                    m_measureFile.MParam.EDSP.Path = EDS_path;
                    if (!Directory.Exists(EDS_path))
                    {
                        Directory.CreateDirectory(EDS_path);
                    }
                }
                //判断孔状态
                if (m_cutHoles[i].STATE != State.Ready) 
                {
                    log.Warn("测试孔"+ m_cutHoles[i].HoleName+"状态非就绪，不予测量。", true);
                    continue;
                }

                //20201127增加Scanrotate Off
                iSEM.SetScanRotationOff();
                Thread.Sleep(200);

                //20.光束等复位
                iSEM.SetBeamShiftX(0);
                Thread.Sleep(200);
                iSEM.SetBeamShiftY(0);
                Thread.Sleep(200);

                //开始循环工作
                if (i == 0)
                {
                    log.Warn("测量线程：分析点" + m_cutHoles[i].HoleName+"开始测量。", true);
                    m_cutHoles[i].START = DateTime.Now;
                    //切孔操作-开始
                    m_cutHoles[i].STATE = State.InProcess;
                    SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);

                    log.Warn("测量线程：控制样品台至样品分析点位置(R,X,Y,Z) = (" + m_cutHoles[0].Position.R.ToString() + ","
                        + m_cutHoles[0].Position.X.ToString()+","
                        + m_cutHoles[0].Position.Y.ToString()+","
                        + m_cutHoles[0].Position.Z.ToString() + ")", true);

                    #region 坐标恢复
                    //0、先移动Z轴到比较低的位置上。
                    if (m_measureFile.MParam.Tilt)//如果是倾斜样品台，移动Z轴
                    {
                        if (!iSEM.SetStageGotoZ(fSateyZ))
                        {
                            arg.State = false;
                            arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置失败。";
                            SendMsg("1-0");
                            log.Error("测量线程报错：样品台Z轴移动失败,Z为" + fSateyZ.ToString(), false);
                            m_cutHoles[i].STATE = State.Failed;
                            m_cutHoles[i].END = DateTime.Now;
                            m_measureFile.Save();
                            SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                            Thread.Sleep(3000);
                            continue;
                        }
                        while (true)
                        {
                            Thread.Sleep(4000);
                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }
                        //判断是否停止进程
                        if (key_stop)
                        {
                            m_cutHoles[i].STATE = State.Failed;
                            m_cutHoles[i].END = DateTime.Now;
                            m_measureFile.Save();
                            SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                            log.Info("停止键被按下", true);
                            return;
                        }
                    }

                    //1、移动样品台到第一个观测点，先移动R轴，再移动XY轴
                    if (!iSEM.SetStageGotoR(m_cutHoles[0].Position.R))
                    {
                        arg.State = false;
                        arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置失败。";
                        SendMsg("1-0");
                        log.Error("测量线程报错：样品台R轴移动失败,R为" + m_cutHoles[0].Position.ToString(), false);
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                        Thread.Sleep(3000);
                        continue;
                    }
                    while (true)
                    {
                        Thread.Sleep(4000);
                        if (iSEM.GetStageIs() == 0)
                        {
                            break;
                        }
                    }
                    //判断是否停止进程
                    if (key_stop)
                    {
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                        log.Info("停止键被按下", true);
                        return;
                    }

                    //2、移动XY轴
                    if (!iSEM.MoveStageXY(m_cutHoles[0].Position.X, m_cutHoles[0].Position.Y))
                    {
                        arg.State = false;
                        arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置失败。";
                        SendMsg("1-0");
                        log.Error("测量线程报错：样品台XY轴移动失败,(X,Y)为"
                            + m_cutHoles[0].Position.X.ToString() + ","
                            + m_cutHoles[0].Position.Y.ToString()+ ")", false);

 						m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                        Thread.Sleep(3000);
                        continue;
                    }
                    while (true)
                    {
                        Thread.Sleep(4000);

                        if (iSEM.GetStageIs() == 0)
                        {
                            break;
                        }
                    }
                    //判断是否停止进程
                    if (key_stop)
                    {
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                        log.Info("停止键被按下", true);
                        return;
                    }

                    //3、恢复Z轴
                    if (m_measureFile.MParam.Tilt)
                    {
                        //恢复Z轴                    
                        if (!iSEM.SetStageGotoZ(m_cutHoles[0].Position.Z))
                        {
                            arg.State = false;
                            arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置失败。";
                            SendMsg("1-0");
                            log.Error("测量线程报错：样品台Z轴移动失败,Z为" + m_cutHoles[0].Position.Z.ToString(), false);
                            m_cutHoles[i].STATE = State.Failed;
                            m_cutHoles[i].END = DateTime.Now;
                            m_measureFile.Save();
                            SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                            Thread.Sleep(3000);
                            continue;
                        }
                        while (true)
                        {
                            Thread.Sleep(4000);

                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }

                        //判断是否停止进程
                        if (key_stop)
                        {
                            log.Info("停止键按下。", true);

                            m_cutHoles[i].STATE = State.Failed;
                            m_cutHoles[i].END = DateTime.Now;
                            m_measureFile.Save();
                            SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);

                            return;
                        }
                    }

                    arg.State = true;
                    arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置成功。";
                    SendMsg("1-0");

                    //4、设置WD
                    iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD);
                    Thread.Sleep(1000);
                    #endregion

                    //第一个点开始测量
                    if (FirstHole())
                    {
                        //保存文件，将测量状态更改
                        m_cutHoles[i].STATE = State.Success;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    }
                    //失败
                    else
                    {
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    }
                }
                else
                {
                    //其他孔的测量
                    log.Info("测量线程：分析点" + m_cutHoles[i].HoleName + "开始测量。", true);
                    m_cutHoles[i].START = DateTime.Now;
                    m_cutHoles[i].STATE = State.InProcess;
                    SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);

                    //其他孔测量之前的初始化
                    if (!OtherHole_Init())
                    {
                        arg.State = false;
                        arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置失败。";
                        SendMsg("1-0");
                        Thread.Sleep(3000);
                        log.Info("测量线程：" + arg.Message, true);
                        continue;
                    }
                    arg.State = true;
                    arg.Message = "样品台移动到观测点：" + m_cutHoles[i] + "的位置成功。";
                    SendMsg("1-0");

                    //其他孔开始测量
                    if (OtherHole())
                    {
                        //保存文件，将测量状态更改
                        m_cutHoles[i].STATE = State.Success;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    }
                    //失败
                    else
                    {
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                        SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    }
                }

                if(key_stop)
                {
                    m_cutHoles[i].END = DateTime.Now;
                    m_cutHoles[i].STATE = State.Ready;
                    m_measureFile.Save();
                    SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    arg.Message = "用户停止测量";
                    SendMsg("0-0");
                    break;
                }

                //两个点之间更换，加延时以便完成显示
                Thread.Sleep(3000);
            }



        }

        //检查硬件连接是否正常
        public bool ConnectHardware()
        {
            //返回硬件的连接状态
            return iSEM.ConnectStatus();
        }

        //设置工作文件夹
        public bool SetWorkingFolderStr()
        {
            WorkingFolder = m_measureFile.FilePath;
            return true;
        }

        //插入PT针
        public bool InsertPT()
        {
            string fn = m_ProgramFolder + "\\Macro\\" + MacoInsertPt;
            //SendMsg("调用宏插入PT针宏文件" + fn);
            iSEM.CMDMCFFilename(fn);
            //延时1s？？
            Thread.Sleep(1000);
            return true;
        }

        //撤出PT针
        public bool RetractPT()
        {
            string fn = m_ProgramFolder + "\\Macro\\" + MacoRetractPt;
            //SendMsg("调用宏撤出PT针宏文件" + fn);
            iSEM.CMDMCFFilename(fn);
            //延时1s？？
            Thread.Sleep(1000);
            return true;
        }

        //PT沉积
        public bool PTWork()
        {
            //执行PT沉积的ELY文件
            if (!ExcuteEly(m_measureFile.MParam.PTTemp))
            {
                return false;
            }

            //等待沉积完成
            while (true)
            {
                Thread.Sleep(7000);
                if (iSEM.GetFIBMode() == 0)
                {
                    break;
                }
            }
            return true;
        }

        //FIB切割
        public bool FIBWork()
        {
            //执行PT沉积的ELY文件
            if (!ExcuteEly(m_measureFile.MParam.FIBTemp))
            {
                return false;
            }

            //等待切割完成
            while (true)
            {
                Thread.Sleep(10000);
                if (iSEM.GetFIBMode() == 0)
                {
                    break;
                }
            }

            return true;
        }

        //执行ELY文件的步骤
        public bool ExcuteEly(string a_filename)
        {
            //执行ELy文件有三个动作
            //1. 选择ELY文件
            //SendMsg("选择ELY文件");
            if (!iSEM.CmdFIBLoadELY(a_filename))
            {
                //SendMsg("选择ELY文件失败");
                return false;
            }
            Thread.Sleep(1000);
            //2. 确认ELY文件
            //SendMsg("确认ELY文件");
            if (!iSEM.CmdFIBEXPOSUREELY())
            {
                //SendMsg("确认ELY文件失败");
                return false;
            }
            Thread.Sleep(1000);
            //3. 执行ELY文件
            //SendMsg("执行ELY文件");
            if (!iSEM.CmdFIBSTARTELY())
            {
                //SendMsg("执行ELY文件失败");
                return false;
            }
            Thread.Sleep(1000);

            return true;
        }
     
        /// <summary>
        ///13. 自动 定位功能,沉积
        /// </summary>
        /// <returns></returns>
        public bool GetPoistion()
        {
            float x0 = 0, y0 = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0, px = 0;
            int state = 1;
            log.Info("测量线程：13.自动定位、沉积-功能自动定位电压" + m_measureFile.MParam.Location_Voltage.ToString() + "自动定位放大倍数" + m_measureFile.MParam.Location_Magnification.ToString(), true);
            Thread.Sleep(200);
            //1.控制SEM放大600X
            if (!iSEM.SetSEMVoltage(m_measureFile.MParam.Location_Voltage))
            {
                arg.Message = "电压设置" + m_measureFile.MParam.Location_Voltage.ToString("0.0") + "失败";
                arg.State = false;
                SendMsg("1-6");
                log.Error("测量线程报错：13.自动定位、沉积-自动定位电压" + m_measureFile.MParam.Location_Voltage.ToString() + "控制失败", false);
                return false;
            }
            Thread.Sleep(200);
            if (!iSEM.SetMagnification(m_measureFile.MParam.Location_Magnification))
            {
                arg.Message = "放大" + m_measureFile.MParam.Location_Magnification.ToString("0.0") + "倍失败";
                arg.State = false;
                SendMsg("1-6");
                log.Error("测量线程报错：13.自动定位、沉积-自动定位放大倍数" + m_measureFile.MParam.Location_Magnification.ToString() + "控制失败", false);
                return false;
            }
            float current = iSEM.GetMagnification();
            while (Math.Abs(current - m_measureFile.MParam.Location_Magnification) > 1)
            {
                iSEM.SetMagnification(m_measureFile.MParam.Location_Magnification);
                Thread.Sleep(200);
                current = iSEM.GetMagnification();
            }
            arg.State = true;
            arg.Message = "放大" + m_measureFile.MParam.Location_Magnification.ToString("0.0") + "倍成功";
            SendMsg("1-6");
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下。", true);
                return false;
            }

            //判断是否为仅拍照，不是则执行FIB操作
            if (!m_measureFile.MParam.Is_Photograph)
            {
                log.Info("测量线程：切换到FIB模式。", true);
                //6.设置FIB拍照参数——扫描时间、束流等
                //7.控制FIB自动亮度、对比度
                Thread.Sleep(200);
                if (!iSEM.CmdFIBModeFIB())
                {
                    arg.Message = "FIB模式切换失败";
                    arg.State = false;
                    SendMsg("1-8");
                    log.Error("测量线程报错：切换到FIB模式失败。", false);
                    return false;
                }
                arg.State = true;
                arg.Picture_Information.Work_Status = "FIB";
                arg.Message = "FIB模式切换成功";
                SendMsg("1-8");
                Thread.Sleep(1000);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下。", true);
                    return false;
                }

                //8.控制FIB拍照
                //9.保存照片======更改路径
                //20201103,FIB使用定位的放大倍数
                String fileName2 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_measureFile.MParam.Location_Magnification.ToString("0") + "_" + ImageName2;
                arg.Picture_Information.Picture_FullPath = fileName2;
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(200);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(200);
                arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
                Thread.Sleep(200);

                //FIB的放大位数，将来会改
                log.Info("测量线程：设置FIB放大倍数"+ m_measureFile.MParam.Location_Magnification.ToString(), true);
                //20201103，FIB使用定位的放大倍数
                if (!iSEM.SetFIBMagnification(m_measureFile.MParam.Location_Magnification))
                {
                    arg.Message = "FIB放大倍数设置失败";
                    arg.State = false;
                    SendMsg("1-9");
                    log.Error("测量线程失败：FIB放大倍数设置失败。", false);
                    return false;
                }
                arg.Message = "FIB放大倍数设置成功";
                arg.State = true;
                SendMsg("1-9");
                Thread.Sleep(200);

                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下。", true);
                    return false;
                }

                //4、设置WD
                iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD);
                Thread.Sleep(1000);

                //20201127增加自动亮度对比度
                if(m_measureFile.MParam.FIBDo)
                {
                    if(m_measureFile.MParam.FIBAutoBC)
                    {
                        //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
                        float m_TempBrightness = 50.0f;
                        float m_TempContrast = 30.0f;
                        if (m_measureFile.MParam.SampleName == "3")
                        {
                            m_TempBrightness = 50.0f;
                            m_TempContrast = 30.0f;
                            iSEM.SetAutoVideoOff();
                            Thread.Sleep(200);
                            iSEM.SetBrightness(m_TempBrightness); //50.0f
                            Thread.Sleep(200);
                            iSEM.SetContrast(m_TempContrast); //30.0f
                            Thread.Sleep(200);
                        }
                        else //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题  end
                        {
                            iSEM.SetAutoVideoBrightnessAndContrast();
                            //20201128陈工建议增加
                            Thread.Sleep(200);
                            iSEM.SetAutoBright(100);
                            Thread.Sleep(200);
                            iSEM.SetAutoContrast(100);
                            Thread.Sleep(5000);
                        }      
                    }
                    else
                    {
                        iSEM.SetAutoVideoOff();
                        Thread.Sleep(200);
                        iSEM.SetBrightness(m_measureFile.MParam.FIBB);
                        Thread.Sleep(200);
                        iSEM.SetContrast(m_measureFile.MParam.FIBC);
                        Thread.Sleep(200);
                    }
                    
                }


                //拍照前改变速度,延时
                iSEM.CloseReduced();
                Thread.Sleep(200);
                //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
                //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);
                if (!GetImage(fileName2))
                {
                    arg.Message = "FIB拍照失败";
                    arg.State = false;
                    SendMsg("1-11");
                    log.Error("测量线程报错：FIB拍照失败。", false);
                    return false;
                }
                arg.State = true;
                arg.Picture_Information.Picture_FullPath = fileName2;
                arg.Message = "FIB拍照成功";
                SendMsg("1-11");
                Thread.Sleep(200);
                SendMsg("1-16");
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下。", true);
                    return false;
                }

                iSEM.CmdFIBModeSEM();
                Thread.Sleep(200);
               
                //10.将照片传给客户，返回梯形位置坐标，及样品类型参数（是否需要PT沉积，PT坐标位置，PT宽度、PT高度、梯形上、下边及深度、扫描时间、束流、样品放大倍数1、样品放大倍数2等切割参数）
                log.Info("测量线程：调用图像处理接口，准备移动样品台", true);
                log.Info("文件名=" + fileName2, true);
                log.Info("样品类型=" + m_measureFile.MParam.SampleName, true);
                log.Info("供应商名称=" + m_measureFile.MParam.Firm, true);
                wr.Img_Cut_Position(fileName2, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out x1, out y1, out x2, out y2, out state);
                log.Info("FIB梯形左上角和右上角位置信息= (" + x1.ToString() + ", " + y1.ToString() + "), (" + x2.ToString() + ", " + y2.ToString()+")", true);
                log.Info("准备移动样品台返回状态=" + state.ToString(), true);
                if (state == 1)
                {
                    //20201128将移动光束改为移动ely文件中的参数来实现沉积和切割
                    float xc = (x1 + x2)/2;
                    float yc = (y1 + y2)/2;
                    x0 = xc - 512;
                    y0 = 384 - yc;
                    log.Info("移动像素 x = " + x0.ToString() + ",y=" + y0.ToString(), true);
                    px = iSEM.GetPixelSize();
                    //修改FIB切割的ELY文件坐标
                    XmlDocument xmlDoc = new XmlDocument();
                    xmlDoc.Load(m_measureFile.MParam.FIBTemp);//加载baixml文件，xmlpath 为XML文件的路径du
                    XmlNode xns = xmlDoc.SelectSingleNode("ELAYOUT/STRUCTURE_LIST/STRUCTURE/LAYER_REFERENCE/TRAPEZOID");
                    if (xns != null)
                    {
                        XmlAttributeCollection attributeCol = xns.Attributes;
                        //遍历自己点属性
                        double width_a = Convert.ToDouble(attributeCol.GetNamedItem("width_a").Value) / 2.0;
                        log.Info("XML-Width_a = " + width_a.ToString(), true);
                        foreach (XmlAttribute attri in attributeCol)
                        {
                            if (attri.Name == "x")
                            {
                                attri.InnerText = ((x0 * px)*1000000 - width_a).ToString();
                                log.Info("XML-TopLeft-X = " + attri.InnerText, true);
                            }
                            else if (attri.Name == "y")
                            {
                                attri.InnerText = ((y0 * px)*1000000-2.791).ToString();
                                log.Info("XML-TopLeft-Y = " + attri.InnerText, true);
                            }
                        }
                    }
                    xns = xmlDoc.SelectSingleNode("ELAYOUT/STRUCTURE_LIST/STRUCTURE/LAYER_REFERENCE/RECT");
                    if (xns != null)
                    {
                        XmlAttributeCollection attributeCol = xns.Attributes;
                        double width = Convert.ToDouble(attributeCol.GetNamedItem("width").Value) / 2.0;
                        //遍历自己点属性
                        foreach (XmlAttribute attri in attributeCol)
                        {
                            if (attri.Name == "x")
                            {
                                attri.InnerText = ((x0 * px)*1000000 - width).ToString();
                            }
                            else if (attri.Name == "y")
                            {
                                attri.InnerText = (((y0 * px) *1000000) + 2 - 2.791).ToString();
                            }
                        }
                    }
                    xmlDoc.Save(m_measureFile.MParam.FIBTemp);//保存的该XML文件,否则更新无效
                    //判断是否需要PT沉积，如果需要也要修改PT的ELY文件
                    if (m_measureFile.MParam.PT)
                    {
                        xmlDoc = new XmlDocument();
                        xmlDoc.Load(m_measureFile.MParam.PTTemp);//加载baixml文件，xmlpath 为XML文件的路径du
                        xns = xmlDoc.SelectSingleNode("ELAYOUT/STRUCTURE_LIST/STRUCTURE/LAYER_REFERENCE/RECT");
                        if (xns != null)
                        {
                            XmlAttributeCollection attributeCol = xns.Attributes;
                            double width = Convert.ToDouble(attributeCol.GetNamedItem("width").Value) / 2.0;
                            //因为ELY文件里的矩形高就是负值，所以在下面的Y值加上这个值就好。
                            double height = Convert.ToDouble(attributeCol.GetNamedItem("height").Value) / 1.5;
                            //遍历自己点属性
                            foreach (XmlAttribute attri in attributeCol)
                            {
                                if (attri.Name == "x")
                                {
                                    attri.InnerText = ((x0 * px) * 1000000 - width).ToString();
                                }
                                else if (attri.Name == "y")
                                {
                                    attri.InnerText = ((y0 * px) * 1000000 - 2.791 - height).ToString();
                                }
                            }
                        }
                        xmlDoc.Save(m_measureFile.MParam.PTTemp);
                    }

                    if (hand_intervene == 1)
                    {
                        MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                    }
                }
                else
                {
                    arg.Message = "图像接口参数state返回值为零";
                    arg.State = false;
                    SendMsg("1-12");
                    if (hand_intervene == 1)
                    {
                        if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        log.Error("测量线程报错：自动定位图像接口返回0", false);
                        return false;
                    }

                    log.Error("测量线程报错：自动定位图像接口返回0", false);
                    return false;
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

                //11.自动工具样品类型参数确定是否需要PT沉积
                if (m_measureFile.MParam.PT)
                {
                    if (!iSEM.CmdFIBModeFIB())
                    {
                        log.Error("测量线程报错：切换到SEM模式失败", false);
                        return false;
                    }
                    Thread.Sleep(200);
                    //12.根据样品类型参数确定是否需要PT沉积，控制PT针插入
                    if (m_measureFile.MParam.Is_Photograph == false && m_measureFile.MParam.PT == true)
                    {
                        log.Info("测量线程：插入PT针" + arg.Message, true);
                        if (!InsertPT())
                        {
                            arg.Message = "插入PT针失败";
                            arg.State = false;
                            SendMsg("1-13");
                            log.Error("测量线程报错："+ arg.Message, false);
                            return false;
                        }
                        arg.State = true;
                        arg.Message = "插入PT针成功";
                        SendMsg("1-13");
                    }
                    //判断是否停止进程
                    if (key_stop)
                    {
                        log.Info("停止键按下", true);
                        return false;
                    }

                    //3. 根据坐标进行PT沉积   
                    if (!PTWork())
                    {
                        arg.Message = "PT沉积失败";
                        arg.State = false;
                        SendMsg("1-14");
                        log.Error("测量线程报错：" + arg.Message, false);
                        return false;
                    }
                    arg.State = true;
                    arg.Message = "PT沉积成功";
                    SendMsg("1-14");
                    //判断是否停止进程
                    if (key_stop)
                    {
                        log.Info("停止键按下", true);
                        return false;
                    }

                    //15.根据样品类型决定是否撤出PT针
                    if (m_measureFile.MParam.Is_Photograph == false && m_measureFile.MParam.PT == true)
                    {
                        if (!RetractPT())
                        {
                            arg.Message = "撤出PT针失败";
                            arg.State = false;
                            SendMsg("1-15");
                            log.Error("测量线程报错：" + arg.Message, false);
                            return false;
                        }
                        arg.State = true;
                        arg.Message = "撤出PT针成功";
                        SendMsg("1-15");
                    }
                    //判断是否停止进程
                    if (key_stop)
                    {
                        log.Info("停止键按下", true);
                        return false;
                    }

                    if (!iSEM.CmdFIBModeSEM())
                    {
                        //arg.Message = "切割前SEM拍照失败。";
                        //arg.State = false;
                        //SendMsg("1-17");
                        log.Error("测量线程报错：切换到SEM模式失败", false);
                        return false;
                    }
                }
            }           

            //14.保存样品1第1号孔中心位置6轴坐标1 XYZMRT到数据库，保存客户返回值信息到数据库
            float[] firstPosition = iSEM.GetStagePosition();
            m_cutHoles[0].Position.X = firstPosition[0];
            m_cutHoles[0].Position.Y = firstPosition[1];
            m_cutHoles[0].Position.Z = firstPosition[2];
            m_cutHoles[0].Position.T = firstPosition[3];
            m_cutHoles[0].Position.R = firstPosition[4];
            m_cutHoles[0].Position.M = firstPosition[5];
            //这里要调用文件保存功能
            arg.Message = "坐标1(" + firstPosition[0].ToString() + ","
                + firstPosition[1].ToString() + ","
                + firstPosition[2].ToString() + ","
                + firstPosition[3].ToString() + ","
                + firstPosition[4].ToString() + ","
                + firstPosition[5].ToString() + ")";
            arg.State = true;
            SendMsg("1-16");
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }
            return true;
        }

        /// <summary>
        /// 14. FIB切割
        /// </summary>
        /// <returns></returns>
        public bool FIBCross()
        {
            int state = 0;
#if CHECK

            float mag = m_measureFile.MParam.Location_Magnification / 3;
            if (mag < 200)
            {
                mag = 200;
            }
            String fileName1 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + mag.ToString("0") + "_" + ImageName111;
           
            iSEM.SetMagnification(mag);
            Thread.Sleep(2000);

            iSEM.CmdSaveRate();
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);
                       
            if (!GetImage(fileName1))
            {
                arg.Message = "切割前SEM拍照失败。";
                arg.State = false;
                SendMsg("1-17");
                log.Info("测量线程报错：SEM切割前图像拍照失败", false);
                return false;
            }

            iSEM.CmdFocusRate();
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);

            arg.Message = "切割前SEM拍照成功。";
            arg.Picture_Information.Picture_FullPath = fileName1;
            arg.State = true;
            SendMsg("1-17");
#endif
            if (!iSEM.CmdFIBModeFIB())
            {
                arg.Message = "切换到FIB模式失败。";
                arg.State = false;
                SendMsg("1-18");
                log.Error("测量线程报错：切换到SEM模式失败", false);
                return false;
            }
            arg.Message = "切换到FIB模式成功。";
            arg.State = true;
            SendMsg("1-18");
            Thread.Sleep(1000);

            iSEM.SetMagnification(m_measureFile.MParam.Location_Magnification);
            float current = iSEM.GetMagnification();
            while (Math.Abs(current - m_measureFile.MParam.Location_Magnification) > 1)
            {
                iSEM.SetMagnification(m_measureFile.MParam.Location_Magnification);
                Thread.Sleep(200);
                current = iSEM.GetMagnification();
            }
            Thread.Sleep(2000);

            //14.自动控制FIB切割
            //1.根据参数设置FIB草率时间（使图清晰），设置梯形上下边及深度、设置束流
            //2.控制FIB进行切割
            //以上1、2步全部用ELY文件代替
            if (!FIBWork())
            {
                arg.Message = "FIB切割失败";
                arg.State = false;
                SendMsg("1-19");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            arg.State = true;
            arg.Message = "FIB切割成功";
            SendMsg("1-19");
            Thread.Sleep(300);
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }


            //做切割后SEM的拍照
            log.Info("测量线程：切割后SEM拍照", true);
            if (!iSEM.CmdFIBModeSEM())
            {
                //arg.Message = "切割后SEM拍照失败。";
                //arg.State = false;
                //SendMsg("1-20");
                log.Error("测量线程报错：切换到SEM模式失败", false);
                return false;
            }
            Thread.Sleep(1000);
#if CHECK
            String fileName2 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + mag.ToString("0") + "_" + ImageName112;

            iSEM.SetMagnification(mag);
            Thread.Sleep(2000);

            iSEM.CmdSaveRate();
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);

            if (!GetImage(fileName2))
            {
                arg.Message = "切割后SEM拍照失败。";
                arg.State = false;
                SendMsg("1-20");
                log.Info("测量线程报错：SEM切割后图像拍照失败", false);
                return false;
            }
            arg.Picture_Information.Picture_FullPath = fileName2;
            arg.Message = "切割后SEM拍照成功。";
            arg.State = true;
            SendMsg("1-20");

            iSEM.CmdFocusRate();
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);

            //5.验证切割准确性：与切割前对比，如果对比误差大，则停止自动执行，进行报警
            wr.Img_Cut_Success(fileName1, fileName2, out state);

            log.Info("测量线程：验证切割准确性，切割前图像："+ fileName1 + "切割后图像" + fileName2 + "返回值为" + state.ToString(), true);

            if (state == 0)
            {
                log.Info("测量线程报错：验证切割准确性失败，图像接口参数state返回值为零。", false);
                arg.Message = "图像接口参数state返回值为零";
                arg.State = false;
                SendMsg("1-22");
                if (hand_intervene == 1)
                {
                    if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                   
                }
                log.Info("测量线程报错：" + arg.Message, false);
            }
            arg.State = true;
            log.Info("验证切割准确性成功。", true);
            arg.Message = "FIB切割校验成功";
            SendMsg("1-22");
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下。", true);
                return false;
            }
#endif
            return true;
        }

        /// <summary>
        /// 16.自动调整SEM找到切割位置，这里不是简单的拉直旋转
        /// </summary>
        /// <returns></returns>
        public bool FindCross()
        {
            float x2 = 0, y2 = 0;
            int state = 0;
            //切换到SEM模式
            if (!iSEM.CmdFIBModeSEM())
            {
                arg.Message = "SEM模式切换失败";
                arg.State = false;
                SendMsg("1-23");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            arg.State = true;
            arg.Message = "SEM模式切换成功";
            SendMsg("1-23");
            arg.Picture_Information.Work_Status = "SEM";
            Thread.Sleep(1000);
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //1.控制SEM放大到300倍
            if (!iSEM.SetSEMVoltage(m_measureFile.MParam.Location_Voltage))
            {
                arg.Message = "电压设置" + m_measureFile.MParam.Location_Voltage.ToString("0.0") + "失败";
                arg.State = false;
                SendMsg("1-24");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            Thread.Sleep(200);

            //iSEM.SetAutoVideoBrightnessAndContrast();
            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
            float m_TempBrightness = 50.0f;
            float m_TempContrast = 30.0f;
            if (m_measureFile.MParam.SampleName == "3")
            {
                m_TempBrightness = 48.0f;
                m_TempContrast = 29.0f;
            }
            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题            
            iSEM.SetAutoVideoOff();
            Thread.Sleep(200);
            iSEM.SetBrightness(m_TempBrightness); //50.0f
            Thread.Sleep(200);
            iSEM.SetContrast(m_TempContrast); //30.0f
            Thread.Sleep(2000);

            float mag = m_measureFile.MParam.Location_Magnification / 3;
            if (mag < 200)
            {
                //add by sun 2020-12-17 设置找梯形照片的放大倍数为400，原来设置成200容易识别错乱
                if (m_measureFile.MParam.SampleName == "3")
                    mag = 400;
                else //add by sun 2020-12-17 设置找梯形照片的放大倍数为400，原来设置成200容易识别错乱
                    mag = 200;
            }
            if (!iSEM.SetMagnification(mag))
            {
                arg.Message = "放大" + mag.ToString("0.0") + "倍失败";
                arg.State = false;
                SendMsg("1-24");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            Thread.Sleep(200);
            float current = iSEM.GetMagnification();
            Thread.Sleep(200);
            while (Math.Abs(current - mag) > 2)
            {
                iSEM.SetMagnification(mag);
                Thread.Sleep(200);

                current = iSEM.GetMagnification();
                Thread.Sleep(200);
            }
            arg.State = true;
            arg.Message = "放大" + mag.ToString("0.0") + "倍成功";
            SendMsg("1-24");
            Thread.Sleep(2000);
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //3.控制SEM拍照
            //String fileName4 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + mag.ToString("0") + "_" + ImageName4;
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称
            String fileName4 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + mag.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageName4;
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end
            log.Info("fileName4====================" + fileName4, true);
            arg.Picture_Information.Picture_FullPath = fileName4;
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(200);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(200);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(200);

            //拍照前改变速度,延时
            //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
            //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);

            if (!GetImage(fileName4))
            {
                arg.State = false;
                arg.Message = "SEM拍照找切割位置失败";
                SendMsg("1-25");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            arg.Picture_Information.Picture_FullPath = fileName4;
            arg.State = true;
            arg.Message = "SEM拍照成功";
            SendMsg("1-25");
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //4.将照片传给客户，获取偏移坐标，以及偏移角度
            //5.根据坐标控制SEM移动到切孔位置，居中
            log.Info("测量线程：图像处理接口，准备移动样品台", true);
            log.Info("文件名=" + fileName4, true);
            wr.Img_Trapezoid_Top_Center_Position(fileName4,Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out x2, out y2, out state);

            log.Info("梯形中心点返回数据=" + x2.ToString() + ", " + y2.ToString(), true);
            log.Info("准备移动样品台返回状态=" + state.ToString(), true);
            if (state == 1)
            {
                //1. 根据客户PT沉积坐标控制FIB调整到中心位置？？？？？？？
                if (!MoveToPixByMoveStage(x2, y2))
                {
                    arg.State = false;
                    arg.Message = "移动到新(" + x2.ToString() + "," + y2.ToString() + ")位置失败";
                    SendMsg("1-26");
                    log.Error("测量线程报错：" + arg.Message, false);
                    return false;
                }
                //判断是否移动完成
                while (true)
                {
                    Thread.Sleep(4000);
                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                arg.State = true;
                arg.Message = "移动到新(" + x2.ToString() + "," + y2.ToString() + ")位置成功";
                SendMsg("1-26");

                //高倍到低倍不进行对焦

                //拍照前改变速度,延时
                //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
                //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                //String fileName10 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + mag.ToString("0") + "_" + ImageName10;
                //add by zjx 2020-12-21 根据客户的需求修改图片的名称
                String fileName10 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + mag.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageName10;
                //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
                log.Info("fileName10====================" + fileName10, true);

                if (!GetImage(fileName10))
                {
                    //arg.State = false;
                    //arg.Message = "SEM拍照失败";
                    //SendMsg("1-25");
                    //return false;
                    log.Info("测量线程报错：找到已切割的位置拍照失败", true);
                }

                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                if (hand_intervene == 1)
                {
                    MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                }
            }
            else
            {
                arg.Message = "图像接口参数state返回值为零";
                arg.State = false;
                SendMsg("1-26");
                if (hand_intervene == 1)
                {
                    if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            return true;
        }

        /// <summary>
        /// 17.自动控制SEM拍截面照
        /// </summary>
        /// <returns></returns>
        public bool ShotSection(ref List<String> limg_path, ref List<float> lsize)
        {
            int state = 0;
#region 设置拍照的电压
            log.Info("测量线程：设置拍照电压" + m_measureFile.MParam.Photograph_Voltage.ToString(), true);
            //1、放大倍数参数photograph_
            if (!iSEM.SetSEMVoltage(m_measureFile.MParam.Photograph_Voltage))
            {
                arg.Message = "电压设置" + m_measureFile.MParam.Photograph_Voltage.ToString("0.0") + "失败";
                arg.State = false;
                SendMsg("1-27");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            //add
#endregion
            Thread.Sleep(200);
#region 设置拍照的放大倍数
            log.Info("测量线程：设置拍照放大倍数====" + m_measureFile.MParam.Photograph_Magnification.ToString(), true);
            if (!iSEM.SetMagnification(m_measureFile.MParam.Photograph_Magnification))
            {
                arg.Message = "放大倍数调整失败";
                arg.State = false;
                SendMsg("1-27");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }

            float set = m_measureFile.MParam.Photograph_Magnification;
            float current = iSEM.GetMagnification();
            while(Math.Abs(current- set) > 1)
            {
                iSEM.SetMagnification(m_measureFile.MParam.Photograph_Magnification);
                Thread.Sleep(200);
                current = iSEM.GetMagnification();
            }
            
            arg.Message = "放大" + m_measureFile.MParam.Photograph_Magnification.ToString()+ "成功";
            arg.State = true;
            SendMsg("1-27");
            Thread.Sleep(3000 + (Int32)cycle_time);

            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }
            #endregion

            #region 拍摄矩形的切割孔，使用拍照的放大倍数
            //if(!iSEM.SetAutoVideoBrightnessAndContrast())
            //{
            //    log.Info("测量线程报错：自动开启亮度对比度失败", false);
            //    return false;
            //}
            //Thread.Sleep(5000);

            //2.控制SEM自动对焦、亮度、对比度-接口
            //add by sun 2020-12-16 解决第5/6类样品 2000倍对焦不好问题
            if ((m_measureFile.MParam.SampleName == "2")||(m_measureFile.MParam.SampleName == "3"))
                iSEM.SetReduced(402, 128, 600, 600);
            else  //add by sun 2020-12-16 解决第5/6类样品 2000倍对焦不好问题 end
                iSEM.SetReduced(402, 128, 340, 256);
            Thread.Sleep(200);
            //add by sun 2020 - 12 - 15 拍截面图调用蔡司接口时，要保证扫描速度5以上，自动亮度对比度功能关闭
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedFocus);//CmdFocusRate(5);
            //add by sun 2020 - 12 - 15 拍截面图调用蔡司接口时，要保证扫描速度5以上，自动亮度对比度功能关闭 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));
            log.Info("测量线程：17.自动控制SEM拍截面照-关闭自动亮度对比度开始！", true);
            if (!iSEM.SetAutoVideoOff())
            {
                log.Error("测量线程报错：关闭自动亮度对比度失败", false);
                return false;
            }
            Thread.Sleep(5000);
            log.Info("测量线程：17.自动控制SEM拍截面照-关闭自动亮度对比度结束！", true);
            log.Info("测量线程：17.自动控制SEM拍截面照-自动对焦开始！", true);
            if (ImageFocus1(false))
            {
                arg.Message = "自动对焦完成";
                arg.State = true;
                SendMsg("1-28");
            }
            else
            {
                arg.Message = "自动对焦失败";
                arg.State = false;
                SendMsg("1-28");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            log.Info("测量线程：17.自动控制SEM拍截面照-自动对焦结束！", true);
            iSEM.CloseReduced();
            Thread.Sleep(200);

            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(200 + Convert.ToInt32(cycle_time));
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
            float m_TempBrightness = 50.0f;
            float m_TempContrast = 30.0f;
         
            if (m_measureFile.MParam.SampleName == "3")
            {
                m_TempBrightness = 50f;
                m_TempContrast = 29f;
                iSEM.SetBrightness(m_TempBrightness); //50.0f
                Thread.Sleep(200);
                iSEM.SetContrast(m_TempContrast); //30.0f
                Thread.Sleep(200);
            }
            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题 end

            if (!iSEM.SetAutoVideoBrightnessAndContrast())
            {
                log.Error("测量线程报错：自动开启亮度对比度失败", false);
                return false;
            }            
            Thread.Sleep(5000);

            //3、设置SEM补偿角度
            if (m_measureFile.MParam.Is_Photograph == false)
            {
                log.Info("测量线程：角度补偿" + m_measureFile.MParam.Correction_Angle.ToString()+"度", true);
                if (!TiltCorrection(m_measureFile.MParam.Correction_Angle))
                {
                    arg.Message = "设置SEM进行角度补偿" + m_measureFile.MParam.Correction_Angle.ToString("0") + "度失败";
                    arg.State = false;
                    SendMsg("1-29");
                    log.Error("测量线程报错：" + arg.Message, false);
                    return false;
                }
                arg.State = true;
                arg.Message = "设置SEM进行角度补偿" + m_measureFile.MParam.Correction_Angle.ToString("0") + "度成功";
                SendMsg("1-29");
                Thread.Sleep(200);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Error("停止键按下", false);
                    return false;
                }
            }

            //4、拍照，5、保存照片
            //String fileName5 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "_" + ImageName5;
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称
            String fileName5 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageName5;
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
            log.Info("fileName5====================" + fileName5, true);
            arg.Picture_Information.Picture_FullPath = fileName5;
            arg.Picture_Information.Work_Status = "SEM";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(200);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(200);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(200);
            //拍照前改变速度,延时
            //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
            //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time)*2);
            if (!GetImage(fileName5))
            {
                arg.Message = "SEM拍照失败";
                arg.State = false;
                SendMsg("1-30");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            arg.Picture_Information.Picture_FullPath = fileName5;
            arg.State = true;
            arg.Message = "SEM拍照成功";
            SendMsg("1-30");
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }
#endregion

            if (m_measureFile.MParam.Is_Photograph == false)
            {
#region 对当前矩形进行旋转校正
                //8,计算切割面区域偏移角度及方向
                float degree = 0;
                int direction = 0;
                
                wr.Img_Center_Position_OffsetAngle_Direction(fileName5, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out degree, out direction, out state);
                log.Info("测量线程：2000倍===拍照角度移动,输入图像" + fileName5 + "输出角度为" + degree.ToString() + "输出方向为" + direction.ToString() + "返回值为" + state.ToString(), true);
                log.Info("样品" + m_nWorkHoleNo.ToString() + "计算切割面区域的角度=" + degree.ToString(), true);
                //接口返回像素，*pixelsize,得到坐标点。判断移动方式
                if (state == 1)
                {
                    //梯形角度
                    iSEM.SetScanRotationOn();
                    Thread.Sleep(200);
                    //20201128陈工要求，谭博返回角度*0.7
                    iSEM.SetScanRotation(Convert.ToSingle(degree * m_measureFile.MParam.ScanRotCor));
                    Thread.Sleep(200);

                    arg.State = true;
                    arg.Message = "图像接口返回角度为：" + degree.ToString();
                    SendMsg("1-31");

                    if (hand_intervene == 1)
                    {
                        MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                    }
                }
                else
                {
                    arg.Message = "图像接口参数State返回值为零";
                    arg.State = false;
                    SendMsg("1-31");
                    if(hand_intervene == 1)
                    {
                        if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        //return false;
                    }

                    log.Error("测量线程报错：" + arg.Message, false);
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

                Thread.Sleep(200);

                //12拍照
                //String fileName6 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "_" + ImageName6;
                //add by zjx 2020-12-21 根据客户的需求修改图片的名称
                String fileName6 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageName6;
                //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
                log.Info("fileName6====================" + fileName6, true);
                arg.Picture_Information.Picture_FullPath = fileName6;
                arg.Picture_Information.Work_Status = "SEM";
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(200);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(200);
                arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
                Thread.Sleep(200);
                //拍照前改变速度,延时
                //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
                //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);
                if (!GetImage(fileName6))
                {
                    arg.Message = "SEM拍照失败";
                    arg.State = false;
                    SendMsg("1-33");
                    log.Error("测量线程报错：" + arg.Message, false);
                    return false;
                }
                arg.Picture_Information.Picture_FullPath = fileName6;
                arg.State = true;
                arg.Message = "SEM拍照成功";
                SendMsg("1-33");
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }
                #endregion

                #region 获取两个位置上及放大倍数
                //计算两个测量区域坐标
                List<System.Drawing.Point> ct = new List<System.Drawing.Point>();
                List<float> mag = new List<float>();
                System.Drawing.Point ct0;
                float mag1, mag2, magMax;
                //log.Info("测量线程：图像处理接口，计算两个放大区域坐标，输入图像" + fileName6.ToString() + "控制失败", true);
                wr.Img_Measure_Region_Position(fileName6, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out ct, out mag, out ct0, out state);

                log.Info("测量线程：图像处理接口返回值为" + state.ToString() +
                    "，计算两个放大区域坐标，输入图像" + fileName6.ToString() +
                    "输入样品" + Convert.ToInt32(m_measureFile.MParam.SampleName) +
                    "输入产品" + m_measureFile.MParam.Firm.ToString()
                    + "输出中心点1为(" + ct[0].X.ToString() + "," + ct[0].Y.ToString() + ")"
                    + "，输出放大倍数1==" + mag[0]
                    + "倍，输出中心点2为(" + ct[1].X.ToString() + "," + ct[1].Y.ToString() + ")"
                    + "输出放大倍数2==" + mag[0]
                    + "倍，输出中心点3为(" + ct0.X.ToString() + "," + ct0.Y.ToString() + ")", true);
                #endregion
                if (state == 1 && ct.Count != 0 && mag.Count != 0)
                {
                    arg.State = true;
                    arg.Message = "获取位置及放大倍数成功";
                    SendMsg("1-34");

                    #region 记录初始设置的BeamShift的百分比和样品台XY位置
                    float xs = iSEM.GetBeamShiftX();
                    Thread.Sleep(200);
                    float ys = iSEM.GetBeamShiftY();
                    Thread.Sleep(200);
                    float xpCur = iSEM.GetStageAtX();
                    Thread.Sleep(200);
                    float ypCur = iSEM.GetStageAtY();
                    Thread.Sleep(200);
                    log.Info("测量线程：原来的光束偏移量x = " + xs.ToString()
                        + "y=" + ys.ToString() + ","
                        + "原来样品台的位置x= " + xpCur.ToString()
                        + "y=" + ypCur.ToString(), true);
                    #endregion

                    //找到放大倍数最大值
                    magMax = mag[0];
                    for (int m = 1; m < mag.Count; m++)
                    {
                        if (mag[m] > magMax)
                        {
                            magMax = mag[m];
                        }
                    }

                    #region 移动到梯形左上角
                    //20201127将视野移动到梯形左上角位置
                    MoveToPix(ct0.X, ct0.Y);

                    log.Info("测量线程：移动到对焦点（ " + ct0.X.ToString()
                        + "," + ct0.Y.ToString() + ")", true);

                    //关闭自动亮度对比度
                    iSEM.SetAutoVideoOff();
                    Thread.Sleep(2000);
                    //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
                    if (m_measureFile.MParam.SampleName == "3")
                    {
                        m_TempBrightness = 50f;
                        m_TempContrast = 29f;
                        iSEM.SetBrightness(m_TempBrightness); //50.0f
                        Thread.Sleep(200);
                        iSEM.SetContrast(m_TempContrast); //30.0f
                        Thread.Sleep(200);
                    }
                    //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题 end
                    //add by sun 2020-12-16 解决第5/6类样品 6000倍对焦不好问题
                    if ( m_measureFile.MParam.SampleName == "3")
                    {
                        iSEM.SetReduced(402, 128, 480, 450);
                    }else
                    {
                        iSEM.SetReduced(402, 128, 340, 256);
                    }
                        
                        
                    Thread.Sleep(200);
                    //add by sun 2020-12-15 拍截面图调用蔡司接口时，要保证扫描速度5以上，自动亮度对比度功能关闭
                    iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedFocus);//CmdFocusRate(5);
                    //add by sun 2020-12-15 拍截面图调用蔡司接口时，要保证扫描速度5以上，自动亮度对比度功能关闭 end
                    Thread.Sleep(200);
                    cycle_time = iSEM.GetCycleTime();
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    

                    //放大到6000倍
                    iSEM.SetMagnification(magMax / 2);
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    set = magMax / 2;
                    current = iSEM.GetMagnification();
                    while (Math.Abs(current - set) > 1)
                    {
                        iSEM.SetMagnification(set);
                        Thread.Sleep(200);
                        current = iSEM.GetMagnification();
                    }
                    log.Info("========测量线程：开始自动聚焦--6000倍！", true);

                    if (m_measureFile.MParam.SampleName == "3")
                    {
                        //add by zjx 2020-12-18 修改亮度对比度 50 29 更成 50 30
                        iSEM.SetBrightness(50.0f); //50.0f
                        Thread.Sleep(200);
                        iSEM.SetContrast(30.0f); //30.0f
                        Thread.Sleep(200);
                        //add by zjx 2020-12-18 修改亮度对比度 50 29 更成 50 30 end
                    }

                    //自动对焦
                    if (!ImageFocus1(true))
                    {
                        log.Info("========测量线程：6000倍自动聚焦失败！", true);
                        return false;
                    }
                    log.Info("========测量线程：6000倍自动聚焦成功！", true);

                    ////自动消像散
                    //if (!ImageStig1())
                    //{
                    //    return false;
                    //}

                    //放大到10000倍
                    iSEM.SetMagnification(magMax);
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    set = magMax;
                    current = iSEM.GetMagnification();
                    while (Math.Abs(current - set) > 1)
                    {
                        iSEM.SetMagnification(set);
                        Thread.Sleep(200);
                        current = iSEM.GetMagnification();
                    }
                    log.Info("========测量线程：开始自动聚焦--12000倍！", true);
                    //自动对焦
                    if (!ImageFocus1(true))
                    {
                        log.Info("========测量线程：12000倍自动聚焦失败！", true);
                        return false;
                    }
                    log.Info("========测量线程：12000倍自动聚焦成功！", true);

                    ////自动消像散
                    //if (!ImageStig1())
                    //{
                    //    return false;
                    //}

                    ////放大到20000倍
                    //iSEM.SetMagnification(magMax*2);
                    //Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    //set = magMax*2;
                    //current = iSEM.GetMagnification();
                    //while (Math.Abs(current - set) > 1)
                    //{
                    //    iSEM.SetMagnification(set);
                    //    Thread.Sleep(200);
                    //    current = iSEM.GetMagnification();
                    //}

                    ////自动对焦
                    //if (!ImageFocus1())
                    //{
                    //    return false;
                    //}                   
                   
                    iSEM.CloseReduced();
                    Thread.Sleep(200);
                    cycle_time = iSEM.GetCycleTime();
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    #endregion

                    #region 循环拍照
                    for (int n = 0; n < ct.Count; n++)
                    {
                        #region 恢复到拍照的状态

                        iSEM.SetStageGotoX(xpCur);
                        while (true)
                        {
                            Thread.Sleep(4000);

                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }
                        iSEM.SetStageGotoY(ypCur);
                        while (true)
                        {
                            Thread.Sleep(4000);

                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }

                        //恢复原来的放大倍数
                        if (!iSEM.SetMagnification(m_measureFile.MParam.Photograph_Magnification))
                        {
                            log.Error("测量线程报错：第一个区域放大倍数" + mag[n].ToString() + "控制失败", false);
                            return false;
                        }
                        Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                        set = m_measureFile.MParam.Photograph_Magnification;
                        current = iSEM.GetMagnification();
                        while (Math.Abs(current - set) > 1)
                        {
                            iSEM.SetMagnification(set);
                            Thread.Sleep(200);
                            current = iSEM.GetMagnification();
                        }


                        //恢复BeamShift的百分比值
                        iSEM.SetBeamShiftX(xs);
                        Thread.Sleep(200);
                        iSEM.SetBeamShiftY(ys);
                        Thread.Sleep(200);

                        #endregion

                        #region 移动到指定点位置
                        if (!MoveToPix(ct[n].X, ct[n].Y))
                        {
                            arg.State = false;
                            arg.Message = "移动到第一个点位置失败";
                            SendMsg("1-" + (35 + n).ToString());
                            //移动到第一个点失败
                            log.Error("测量线程报错：移动到点(" + ct[n].X.ToString() + "," + ct[n].Y.ToString() + ")失败", false);
                        }

                        log.Info("测量线程：移动到第1个点（ " + ct[n].X.ToString()
                            + "," + ct[n].Y.ToString() + ")", true);
                        #endregion

                        #region 如果是第一个点，则1W倍对焦
                        if (n == 0)
                        {
                            ////在第一个点上放大1W倍对焦
                            //if (!iSEM.SetMagnification(mag[n]))
                            //{
                            //    log.Info("测量线程报错：第一个区域放大倍数" + mag[n].ToString() + "控制失败", false);
                            //    return false;
                            //}
                            //Thread.Sleep(100 + Convert.ToInt32(cycle_time));
                            //while (true)
                            //{
                            //    current = iSEM.GetMagnification();
                            //    if (Math.Abs(current - mag[n]) < 1)
                            //    {
                            //        Thread.Sleep(200);
                            //        break;
                            //    }
                            //    Thread.Sleep(200);
                            //    iSEM.SetMagnification(set);
                            //    Thread.Sleep(200);
                            //}
                            //if (m_measureFile.MParam.SampleName == "2")
                            //{
                            //    //窗口对焦
                            //    iSEM.SetReduced1(340, 1, 340, 256);
                            //    Thread.Sleep(200);
                            //    iSEM.CmdFocusRate();
                            //    Thread.Sleep(200);
                            //    cycle_time = iSEM.GetCycleTime();
                            //    Thread.Sleep(100 + Convert.ToInt32(cycle_time));
                            //    //自动对焦
                            //    if (!ImageFocus1(false))
                            //    {
                            //        return false;
                            //    }
                            //    //恢复全屏
                            //    iSEM.CloseReduced();
                            //    Thread.Sleep(200);
                            //    cycle_time = iSEM.GetCycleTime();
                            //    Thread.Sleep(100 + Convert.ToInt32(cycle_time));
                            //}
                            //else
                            //{
                            //    //窗口对焦
                            //    //iSEM.SetReduced(402, 128, 800, 600);
                            //    //Thread.Sleep(200);
                            //    iSEM.CmdFocusRate();
                            //    Thread.Sleep(200);
                            //    cycle_time = iSEM.GetCycleTime();
                            //    Thread.Sleep(100 + Convert.ToInt32(cycle_time));
                            //    //自动对焦
                            //    if (!ImageFocus1(false))
                            //    {
                            //        return false;
                            //    }
                            //    //恢复全屏
                            //    //iSEM.CloseReduced();
                            //    //Thread.Sleep(200);
                            //    cycle_time = iSEM.GetCycleTime();
                            //    Thread.Sleep(100 + Convert.ToInt32(cycle_time));
                            //}

                            log.Info("========测量线程：进入内部观察，不对焦！", true);
                            //增亮图像
                            iSEM.SetAutoVideoOff();
                            Thread.Sleep(200);

                            float currentBright = iSEM.GetBrightness();
                            Thread.Sleep(200);

                            float currentContrast = iSEM.GetContrast();
                            Thread.Sleep(200);

                            //add by sun 2020-12-17 黄工觉得太亮
                            int m_BrightMore = 2;
                            int m_ContrastMore = 2;
                            if (m_measureFile.MParam.SampleName == "3")
                            {
                                m_BrightMore = 0;
                                m_ContrastMore = 0;
                            }
                            //add by sun 2020-12-17 黄工觉得太亮 end
                            iSEM.SetBrightness(currentBright + m_BrightMore);
                            Thread.Sleep(200);

                            iSEM.SetContrast(currentContrast + m_ContrastMore);
                            Thread.Sleep(200);
                        }
                        #endregion

                        //add by sun 2020-12-17 根据客户要求，3大类样品需要在5000倍下在拍摄一张图片，不需要分析
                        //if((m_measureFile.MParam.SampleName=="3")&&(n==0))
                        //{ 
                        //    if (!GetImageFromSEM(mag[n]/2))
                        //        log.Info("测量线程报错：第一个区域放大一半倍数" + (mag[n]/2).ToString() + "控制失败", true);
                        //}
                        //add by sun 2020-12-17 根据客户要求，3大类样品需要在5000倍下在拍摄一张图片，不需要分析 end
                        #region 拍照
                        if (!iSEM.SetMagnification(mag[n]))
                        {
                            arg.State = false;
                            arg.Message = "移动到第一个点位置拍照失败";
                            SendMsg("1-35");
                            log.Error("测量线程报错：第一个区域放大倍数" + mag[n].ToString() + "控制失败", false);
                            return false;
                        }
                        log.Info("========测量线程：移动到第一个点位置拍照完成！", true);
                        Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                        set = mag[n];
                        current = iSEM.GetMagnification();
                        while (Math.Abs(current - set) > 1)
                        {
                            iSEM.SetMagnification(set);
                            Thread.Sleep(200);
                            current = iSEM.GetMagnification();
                        }


                        //获取像素大小
                        lsize.Add(iSEM.GetPixelSize());
                        Thread.Sleep(200);

                        //String fileName7 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + mag[n].ToString() + "_" + n.ToString() + "_" + ImageNameTwo_1;
                        //add by zjx 2020-12-21 根据客户的需求修改图片的名称
                        String fileName7 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + mag[n].ToString() + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + n.ToString() + "-" + ImageNameTwo_1;
                        //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
                        log.Info("fileName7====================" + fileName7, true);
                        arg.Picture_Information.Picture_FullPath = fileName7;
                        arg.Picture_Information.Work_Status = "SEM";
                        arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                        Thread.Sleep(200);
                        arg.Picture_Information.Magnification = iSEM.GetMagnification();
                        Thread.Sleep(200);
                        arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
                        Thread.Sleep(200);
                        //拍照前改变速度,延时
                        iSEM.CmdLineScan();
                        Thread.Sleep(200);
                        cycle_time = iSEM.GetCycleTime();
                        Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
                        if (!GetImage(fileName7))
                        {
                            arg.State = false;
                            arg.Message = "移动到第一个点位置失败";
                            SendMsg("1-35");
                            log.Error("测量线程报错：" + arg.Message, false);
                            return false;
                        }
                        log.Info("========测量线程：移动到第一个点位置完成！", true);
                        iSEM.CmdPixelScan();
                        Thread.Sleep(200);
                        limg_path.Add(fileName7);
                        arg.Picture_Information.Picture_FullPath = fileName7;
                        arg.State = true;
                        arg.Message = "移动到第一个点位置拍照成功";
                        SendMsg("1-35");
                        iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
                        Thread.Sleep(200);
                        cycle_time = iSEM.GetCycleTime();
                        Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
                        // add by zjx 在测量图上显示放大倍数和像素大小等信息
                        float size = iSEM.GetPixelSize();
                        SaveMeasDataPic(fileName7,mag[n], size);
                        // add by zjx 在测量图上显示放大倍数和像素大小等信息 end 
                        #endregion
                    }

                    #endregion

                    if (hand_intervene == 1)
                    {
                        MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                    }
                }
                else
                {
                    if (hand_intervene == 1)
                    {
                        if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                        {
                            // return false;
                        }
                    }
                    else
                    {
                        //return false;
                    }

                    arg.State = false;
                    arg.Message = "获取位置及放大倍数失败";
                    SendMsg("1-34");

                    log.Error("测量线程报错：" + arg.Message, false);
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

            }

            ////14光束复位和Rotation关闭开关
            //arg.Message = "光束复位成功";
            //arg.State = true;
            //SendMsg("1-36");
            iSEM.SetTiltAngleOff();
            Thread.Sleep(200);
            iSEM.SetScanRotationOff();
            Thread.Sleep(200);
            iSEM.SetBeamShiftX(0);
            Thread.Sleep(200);
            iSEM.SetBeamShiftY(0);
            Thread.Sleep(200);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
            return true;
        }

        //第一个孔的测试过程
        public bool FirstHole()
        {
            // add by zjx 2020-12-18 为了测试只做能谱部分
            if (m_measureFile.MParam.IsonlyEDSForDebug == true)
            {
                //add by sun 2020-12-17 不同样品电压、电流不一致，应设置灵活。123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA 
                log.Warn("测量线程：第一孔=====设置拍照电压 123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA  目前是第 " + m_measureFile.MParam.SampleName + " 类！", true);
                if (!SetVoltageAndIPROBE())
                {
                    log.Error("测量线程：第一孔=====设置电压电流失败！目前是第 " + m_measureFile.MParam.SampleName + " 类！", false);
                    return false;
                }
                //add by sun 2020-12-17 不同样品电压、电流不一致，应设置灵活。123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA end

                //设置拉直的放大倍数
                log.Info("测量线程：第一个孔的测试过程-设置SEM放大倍数为拉直放大倍数，放大倍数为" + m_measureFile.MParam.Stretch_Magnification.ToString(), true);

                if (!iSEM.SetMagnification(m_measureFile.MParam.Stretch_Magnification))
                {
                    log.Error("测量线程报错：第一个孔的测试过程-设置SEM放大倍数为拉直放大倍数失败，放大倍数为" + m_measureFile.MParam.Stretch_Magnification.ToString(), false);
                    arg.Message = "测量线程报错：拉直放大倍数设置失败！";
                    arg.State = false;
                    SendMsg("1-1");
                    return false;
                }
                float current = iSEM.GetMagnification();
                while (Math.Abs(current - m_measureFile.MParam.Stretch_Magnification) > 1)
                {
                    iSEM.SetMagnification(m_measureFile.MParam.Stretch_Magnification);
                    Thread.Sleep(200);
                    current = iSEM.GetMagnification();
                }
                arg.Message = "拉直放大倍数设置成功！";
                arg.State = true;
                SendMsg("1-1");
                Thread.Sleep(2000);

                //自动化流程-每个点都需要补偿54度
                if (m_measureFile.MParam.Is_Photograph == false)
                {
                    log.Info("测量线程：第一个孔的测试过程-倾斜补偿角度为54度", true);
                    if (!TiltCorrection(54.0f))
                    {
                        log.Error("测量线程报错：倾斜补偿角度为54度失败", false);
                        arg.Message = "角度补偿54度失败！";
                        arg.State = false;
                        SendMsg("1-2");
                        return false;
                    }
                    arg.Message = "角度补偿54度成功！";
                    arg.State = true;
                    SendMsg("1-2");
                    Thread.Sleep(1000);
                    //判断是否停止进程
                    if (key_stop)
                    {
                        log.Info("停止键按下", true);
                        return false;
                    }
                }

                // 2是5/6类样品，不需要拉直
                if (m_measureFile.MParam.SampleName != "2")
                {
                    log.Warn("测量线程：第一个孔的测试过程-拉直操作开始！", true);
                    if (!Straighten_Handle())
                    {
                        log.Info("测量线程报错：第一个孔的测试过程-拉直操作失败。", true);
                        return false;
                    }
                    log.Info("测量线程：第一个孔的测试过程-拉直操作结束！", true);
                    //判断是否停止进程
                    if (key_stop)
                    {
                        log.Info("停止键按下。", true);
                        return false;
                    }
                }
                else
                {
                    arg.Message = "拉直操作自动对焦成功！";
                    arg.State = true;
                    SendMsg("1-3");
                    Thread.Sleep(1000);
                    arg.Message = "拉直拍照成功！";
                    arg.Picture_Information.Picture_FullPath = "";
                    arg.State = true;
                    SendMsg("1-4");
                    Thread.Sleep(1000);
                    arg.Message = "拉直操作完成";
                    arg.State = true;
                    SendMsg("1-5");
                    Thread.Sleep(1000);
                }

                //13. 自动 定位功能  
                log.Warn("测量线程：第一个孔的测试过程-自动定位开始！", true);
                if (!GetPoistion())
                {
                    log.Error("测量线程报错：自动定位失败，程序退出。", false);
                    return false;
                }
                log.Info("测量线程：第一个孔的测试过程-自动定位结束！", true);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下。", true);
                    return false;
                }

                //14.自动控制FIB切割    del by sun 2020-12-15 temp            
                if (m_measureFile.MParam.Is_Photograph == false)
                {
                    if (m_measureFile.MParam.IsCutingForDebug)
                    {
                        log.Warn("测量线程：第一个孔的测试过程-14.自动控制FIB切割开始！==" + m_measureFile.MParam.IsCutingForDebug, true);
                        if (!FIBCross())
                        {
                            log.Error("测量线程报错：自动控制FIB切割失败。", false);
                            return false;
                        }
                        log.Info("测量线程：第一个孔的测试过程-14.自动控制FIB切割结束！", true);
                    }
                }
                //del by sun 2020-12-15 temp end
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }

                //16.找到切割位置
                if (m_measureFile.MParam.Is_Photograph == false)
                {
                    log.Info("测量线程：第一个孔的测试过程-16.找到切割位置开始！", true);
                    if (!FindCross())
                    {
                        return false;
                    }
                    log.Info("测量线程：第一个孔的测试过程-16.找到切割位置结束！", true);
                    //判断是否停止进程
                    if (key_stop)
                    {
                        return false;
                    }
                }
                log.Warn("测量线程：第一个孔的测试过程-17.自动控制SEM拍截面照开始", true);
                //将过程17最后的拍照图片提出给18步进行调用
                List<String> limg_path = new List<string>();
                List<float> lsize = new List<float>();
                //17.自动控制SEM拍截面照
                if (!ShotSection(ref limg_path, ref lsize))
                {
                    //return false;
                }
                log.Info("测量线程：第一个孔的测试过程-17.自动控制SEM拍截面照结束！", true);
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }

                //这段是临时的
                //arg.State = true;
                //arg.Message = "测量尺寸成功";
                //SendMsg("1-40");

                //18.自动层高分析
                if (m_measureFile.MParam.Is_Photograph == false)
                {
                    log.Warn("测量线程：第一个孔的测试过程-18.自动层高分析开始", true);
                    float size = iSEM.GetPixelSize();
                    int state = 1;
                    wr.Img_Measure_Height(limg_path, lsize, data_path + "\\", Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out state);
                    if (state == 0)
                    {
                        arg.Message = "测量尺寸失败";
                        arg.State = false;
                        SendMsg("1-40");
                        return false;
                    }
                    arg.State = true;
                    arg.Message = "测量尺寸成功";
                    SendMsg("1-40");
                    log.Info("测量线程：第一个孔的测试过程-18.自动层高分析结束！", true);
                }
            }
            //add by zjx 2020-12-18 为了测试只做能谱部分 end
            //19.能谱分析
            if (m_measureFile.MParam.EDS)
            {
                log.Warn("测量线程：第一个孔的测试过程-19.能谱分析开始===" + m_measureFile.MParam.EDS, true);
                EDSAnalysis();
                log.Info("测量线程：第一个孔的测试过程-19.能谱分析结束===" + m_measureFile.MParam.EDS, true);
            }
            //20.复位
            log.Info("===========测量线程：20.复位开始", true);
            BeamShiftReset();
            return true;
        }

        //非第一个孔的测试过程
        public bool OtherHole()
        {
            //add by sun 2020-12-17 不同样品电压、电流不一致，应设置灵活。123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA 
            log.Warn("测量线程：非第一孔==设置拍照电压 123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA  目前是第 " + m_measureFile.MParam.SampleName + " 类！", true);
            if (!SetVoltageAndIPROBE())
            {
                log.Error("测量线程：非第一孔==设置电压电流失败！目前是第 " + m_measureFile.MParam.SampleName + " 类！", false);
                return false;
            }
            //add by sun 2020-12-17 不同样品电压、电流不一致，应设置灵活。123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA end
            //设置拉直的放大倍数
            log.Info("设置拉直放大倍数！");
            if (!iSEM.SetMagnification(m_measureFile.MParam.Stretch_Magnification))
            {
                log.Error("拉直放大倍数设置失败，程序退出。", false);
                arg.Message = "拉直放大倍数设置失败！";
                arg.State = false;
                SendMsg("1-1");
                return false;
            }
            float current = iSEM.GetMagnification();
            while (Math.Abs(current - m_measureFile.MParam.Stretch_Magnification) > 1)
            {
                iSEM.SetMagnification(m_measureFile.MParam.Stretch_Magnification);
                Thread.Sleep(200);
                current = iSEM.GetMagnification();
            }
            arg.Message = "拉直放大倍数设置成功！";
            arg.State = true;
            SendMsg("1-1");
            Thread.Sleep(2000);

            //自动化流程-每个点都需要补偿54度
            if (m_measureFile.MParam.Is_Photograph == false)
            {
                log.Info("角度补偿54度！");
                if (!TiltCorrection(54.0f))
                {
                    arg.Message = "角度补偿54度失败！";
                    arg.State = false;
                    SendMsg("1-2");
                    return false;
                }
                arg.Message = "角度补偿54度成功！";
                arg.State = true;
                SendMsg("1-2");
                Thread.Sleep(2000);
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
            }

            if (m_measureFile.MParam.SampleName != "2")
            {
                log.Warn("开始进行拉直操作！");
                if (!Straighten_Handle())
                {
                    log.Info("测量线程报错：拉直操作失败。", true);
                    return false;
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下。", true);
                    return false;
                }
            }
            else
            {
                arg.Message = "拉直操作自动对焦成功！";
                arg.State = true;
                SendMsg("1-3");
                Thread.Sleep(1000);
                arg.Message = "拉直拍照成功！";
                arg.Picture_Information.Picture_FullPath = "";
                arg.State = true;
                SendMsg("1-4");
                Thread.Sleep(1000);
                arg.Message = "拉直操作完成";
                arg.State = true;
                SendMsg("1-5");
            }

            //13. 自动 定位功能
            log.Info("开始进行自动定位！");
            if (!GetPoistion())
            {
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
           
            //14.自动控制FIB切割
            if (m_measureFile.MParam.Is_Photograph == false)
            {
                log.Warn("开始进行FIB切割！");
                if (!FIBCross())
                {
                    return false;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            // 16.找到切割位置
            if (m_measureFile.MParam.Is_Photograph == false)
            {
                log.Warn("开始找切割位置！");
                if (!FindCross())
                {
                    return false;
                }
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
            }

            //将过程17最后的拍照图片提出给18步进行调用
            List<String> limg_path = new List<string>();
            List<float> lsize = new List<float>();
            //17.自动控制SEM拍截面照
            log.Warn("开始控制SEM拍截面照！");
            if (!ShotSection(ref limg_path, ref lsize))
            {
                //return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //这段是临时的
            //arg.State = true;
            //arg.Message = "测量尺寸成功";
            //SendMsg("1-40");

            //18.自动层高分析
            if (m_measureFile.MParam.Is_Photograph == false)
            {
                log.Warn("开始进行层高分析！");
                float size = iSEM.GetPixelSize();
                int state = 1;
                wr.Img_Measure_Height(limg_path, lsize, data_path + "\\", Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out state);
                if (state == 0)
                {
                    arg.Message = "测量尺寸失败";
                    arg.State = false;
                    SendMsg("1-40");
                    return false;
                }
                arg.State = true;
                arg.Message = "测量尺寸成功";
                SendMsg("1-40");
            }

            //19.能谱分析
            if (m_measureFile.MParam.EDS)
            {
                log.Warn("开始进行能谱分析！");
                EDSAnalysis();
            }

            //20.复位  del by sun 2020-12-15
            //BeamShiftReset();
            //del by sun 2020-12-15 end

            return true;
        }

        //测试完第一个孔后的样品台初始化操作。
        //再调用CommonWork执行非第一个孔的测试过程
        public bool OtherHole_Init()
        {
            CutHole currentHole = m_cutHoles[m_nWorkHoleNo];
#region 初始化
            //1、不只拍照，且不是倾斜观测，则移动T轴
            if (m_measureFile.MParam.Is_Photograph == false && m_measureFile.MParam.Tilt == false)
            {
                //4. 控制样品台T轴归0，R轴变为坐标1、Z/M轴作为坐标2保存不变
                if (!iSEM.SetStageGotoT(0))
                {
                    log.Error("样品台归零失败", false);
                    return false;
                }
                while (true)
                {
                    Thread.Sleep(5000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }  
            }

            //2、如果是倾斜观测，则移动Z轴
            if(m_measureFile.MParam.Tilt==true)
            {
                //4. 控制样品台T轴归0，R轴变为坐标1、Z/M轴作为坐标2保存不变
                //if (!iSEM.SetStageGotoZ(currentHole.Position.Z - m_measureFile.MParam.ZDistance/1000))

                //20201109, Z轴降到安全的位置上
                if(!iSEM.SetStageGotoZ(fSateyZ))
                {
                    log.Error("测量线程报错：样品台Z回到安全位置失败", false);
                    return false;
                }
                while (true)
                {
                    Thread.Sleep(5000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }
            }

            //3. 根据光镜坐标控制样品台移动
            if (!iSEM.SetStageGotoR(currentHole.Position.R))
            {
                //SendMsg("移动失败");
                log.Error("测量线程报错：样品台R旋转失败，目标R" + currentHole.Position.R.ToString(), false);
                return false;
            }
            log.Info("移动R轴到="+ currentHole.Position.R.ToString(), true);
            while (true)
            {
                Thread.Sleep(5000);

                if (iSEM.GetStageIs() == 0)
                {
                    break;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            if(!iSEM.MoveStageXY(currentHole.Position.X, currentHole.Position.Y))
            {
                //SendMsg("移动失败");
                log.Error("测量线程报错：样品台(X,Y)移动失败失败，目标（x，y）为(" + currentHole.Position.X.ToString()+"," +currentHole.Position.X.ToString()+")", false);

                return false;
            }
            log.Info("移动X轴Y轴=" + currentHole.Position.X.ToString() + "  " + currentHole.Position.Y.ToString(), true);
            while (true)
            {
                Thread.Sleep(10000);

                if (iSEM.GetStageIs() == 0)
                {
                    break;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //4、倾斜观测时恢复Z轴
            if (m_measureFile.MParam.Tilt == true)
            {
                //4. 控制样品台T轴归0，R轴变为坐标1、Z/M轴作为坐标2保存不变
                if (currentHole.Position.Z > 0.043)
                {
                    log.Error("测量线程报错：样品台Z过高，目标z" + currentHole.Position.Z.ToString(), false);
                    return false;
                }
                if (!iSEM.SetStageGotoZ(currentHole.Position.Z))
                {
                    log.Error("测量线程报错：样品台Z移动失败，目标z" + currentHole.Position.Z.ToString(), false);

                    return false;
                }
                while (true)
                {
                    Thread.Sleep(5000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //判断是否停止进程
                if (key_stop)
                {

                    log.Info("停止键按下", true);
                    return false;
                }
            }

            //5. 控制样品台，调整T轴54度、M/Z/R轴不变
            if (m_measureFile.MParam.Is_Photograph == false && m_measureFile.MParam.Tilt == false)
            {
                if (!iSEM.SetStageGotoT(54))
                {
                    log.Info("测量线程报错：校正54度有误", true);
                    return false;
                }
                while (true)
                {
                    Thread.Sleep(5000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //4、设置WD
            iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD);
            Thread.Sleep(1000);
            #endregion
            return true;
        }

        //初始化拉直操作
        public bool Straighten_Handle()
        {
            if (m_measureFile.MParam.Tilt)
            {
                //倾斜样品台，SEM视野是黑色的
                log.Info("测量线程：恢复到工作位置后重新调亮图像。", true);
                if (!iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD))//5.1mm
                {
                    log.Error("测量线程报错：重新设置到标准工作距离失败。", false);
                    return false;
                }
                Thread.Sleep(7000); //自动亮度对比度使用
     
            }

            //1、自动对焦
            log.Info("测量线程报错：拉直操作前自动对焦开始", true);
            iSEM.SetReduced(402, 128, 340, 256);
            Thread.Sleep(200);
            //add by sun 2020-12-15
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedFocus);//CmdFocusRate(5);
            //add by sun 2020-12-15 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));

            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
            float m_TempBrightness = 50.0f;
            float m_TempContrast = 30.0f;
            if (m_measureFile.MParam.SampleName == "3")
            {
                m_TempBrightness = 48.0f;
                m_TempContrast = 29.0f;
            }
            //add by sun 2020-12-18 解决1类样品拉直太白造成无法拉直问题
            if (m_measureFile.MParam.SampleName == "1")
            {
                m_TempBrightness = 50.0f;
                m_TempContrast = 29.0f;
            }
            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题    
            iSEM.SetAutoVideoOff();
            Thread.Sleep(200);
            iSEM.SetBrightness(m_TempBrightness);//50.0f
            Thread.Sleep(200);
            iSEM.SetContrast(m_TempContrast);//30.0f
            Thread.Sleep(200);

            if (!ImageFocus1(false))
            {
                log.Error("测量线程报错：拉直操作自动对焦失败，程序退出。", false);
                arg.Message = "拉直操作自动对焦失败！";
                arg.State = false;
                SendMsg("1-3");
                return false;
            }

            iSEM.CloseReduced();
            Thread.Sleep(200);

            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));

            iSEM.SetAutoVideoBrightnessAndContrast();
            Thread.Sleep(5000);

            arg.Message = "拉直操作自动对焦成功！";
            arg.State = true;
            SendMsg("1-3");
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下。", true);
                return false;
            }


            //2、拍张照片
            String fileName0 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_measureFile.MParam.Stretch_Magnification.ToString("0") + "_" + ImageName0;
            log.Info("测量线程：设置保存图像的是扫描速度保存图像" + fileName0, true);
            //拍照前改变速度,延时
            //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();//
            //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);
            if (!GetImage(fileName0))
            {
                log.Error("测量线程报错：拉直拍照失败", false);
                arg.Message = "拉直拍照失败";
                arg.State = false;
                SendMsg("1-4");
                return false;
            }
            arg.Message = "拉直拍照成功！";
            arg.Picture_Information.Picture_FullPath = fileName0;
            arg.State = true;
            SendMsg("1-4");
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) +100);

            //3、华为接口，获取旋转角度
            float degree = 0;
            int direction = 0;
            int state = 1;
            wr.Img_OffsetAngle_Direction(fileName0, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out degree, out direction, out state);
            log.Info("测量线程：使用图像处理接口：样品" + m_nWorkHoleNo.ToString() + "初始化拉直角度=" + degree.ToString(), true);
            log.Info("图像处理结果拉直角度=" + degree.ToString(), true);
            log.Info("图像处理结果拉直角度=" + degree.ToString(), true);
            if (state == 0)
            {
                log.Info("测量线程：图像处理接口参数state返回为零" ,false);
                arg.Message = "图像处理接口参数state返回为零";
                arg.State = false;
                SendMsg("1-5");
                if (hand_intervene == 1)
                {
                    if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }

                return false;
            }
            if (direction == 2)
            {
                degree = -degree;
            }

            if (degree != 0)
            {
                //4、拉直，旋转R轴
                log.Info("测量线程：图像拉直，旋转角度" + degree.ToString(), true);

                //选择之前，先降Z轴
                float Zpos = iSEM.GetStageAtZ();
                Thread.Sleep(200);

                log.Info("测量线程：当前Z轴位置" + Zpos.ToString() + "m", true);

                if (!iSEM.SetStageGotoZ(fSateyZ))
                {
                    log.Error("测量线程报错：样品台Z回到安全位置失败", false);
                    return false;
                }
                while (true)
                {
                    Thread.Sleep(4000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

                iSEM.SetStageDeltaR(degree);
                while (true)
                {
                    Thread.Sleep(4000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                if (!iSEM.SetStageGotoZ(Zpos))
                {
                    log.Error("测量线程报错：样品台Z回到安全位置失败", false);
                    return false;
                }
                while (true)
                {
                    Thread.Sleep(4000);

                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

                //4、设置WD
                iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD);
                Thread.Sleep(1000);
            }
            arg.Message = "拉直操作完成";
            arg.State = true;
            SendMsg("1-5");

            return true;
        }

        //角度补偿
        public bool TiltCorrection(float a_fAngle)
        {
            if (!iSEM.SetTiltAngleOn())
            {
                return false;
            }
            Thread.Sleep(200);
            //恢复原始状态
            if (!iSEM.SetTiltAngle(a_fAngle))
            {
                return false;
            }
            return true;
        }

        //拍图
        public bool GetImage(String a_fileName)
        {
            log.Info("获取分辨率开始！", true);
            //3. 获取分辨率
            int[] ImageSize = iSEM.GetImageStore();
            if (ImageSize[0] == 0 || ImageSize[1] == 0)
            {
                return false;
            }
            short width = (short)ImageSize[0];
            short height = (short)ImageSize[1];
            log.Info("获取分辨率结束！"+ a_fileName +"===="+ width+ "*"+height, true);
            //4. 抓图
            if (!iSEM.GrabImage(a_fileName, 0, 0, width, height, 0))
            {
                log.Info("抓图失败！", true);
                return false;
            }

            return true;
        }

        //拍图1
        public bool GetImage1(String a_fileName)
        {
            //3. 获取分辨率
            int[] ImageSize = iSEM.GetImageStore();
            if (ImageSize[0] == 0 || ImageSize[1] == 0)
            {
                return false;
            }
            short width = (short)ImageSize[0];
            short height = (short)ImageSize[1];

            //4. 抓图
            if (!iSEM.GrabZoneImage(a_fileName, 256, 192, 512, 384, 0))
            {
                return false;
            }

            return true;
        }

#region 算法设计
        //执行自动对焦
        public bool ImageFocus()
        {
            if (m_measureFile.MParam.FocusMode == 1)//手动
            {
                if (DialogResult.Yes == MessageBox.Show("图像自动对焦已完成？", "确认消息", MessageBoxButtons.YesNo))
                {
                }
                else
                {
                    return false;
                }
            }
            else if (m_measureFile.MParam.FocusMode == 2)//自有自动
            {
                //郝工增加自动对焦算法
                //处理文件夹
                if (Directory.Exists(focus_path))
                {
                    Directory.Delete(focus_path, true);
                }
                Thread.Sleep(3000);
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(1000);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(1000);

                //再创建文件夹
                Directory.CreateDirectory(focus_path);

                //1、对焦参数类，2、输出工作距离
                int wd = 0;

                //20201015 根据当前的工作距离重新计算对焦位置
                float currentWd = iSEM.GetWorkingDistance();
                //m_measureFile.MParam.AutoFocus.UP = currentWd * 1000000 - m_measureFile.MParam.AutoFocus.Step;
                //m_measureFile.MParam.AutoFocus.Down = currentWd * 1000000 + m_measureFile.MParam.AutoFocus.Step;
                Thread.Sleep(2000);

                float currentMag = iSEM.GetMagnification();
                Thread.Sleep(2000);
                FocusParam pFoucs = new FocusParam();
                if (currentMag <= m_measureFile.MParam.Photograph_Magnification)
                {
                    pFoucs = m_measureFile.MParam.AutoFocus;
                    pFoucs.UP = 5050;
                    pFoucs.Down = 5150;
                    pFoucs.Step = 50;
                    pFoucs.fStep = 10;
                    pFoucs.Range = 50;

                    //4、设置WD
                    iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD);
                    Thread.Sleep(1000);
                }
                else
                {
                    pFoucs = m_measureFile.MParam.AutoFocus;
                    pFoucs.UP = 5000;
                    pFoucs.Down = 5200;
                    pFoucs.Step = 10;
                    pFoucs.fStep = 5;
                    pFoucs.Range = 50;

                    //4、设置WD
                    iSEM.SetWorkingDistance(m_measureFile.ListCutHole[m_nWorkHoleNo].Position.WD);
                    Thread.Sleep(1000);

                }

                //log.Info("修改对焦参数", true);
                AutoFocus(pFoucs, out wd);

                log.Info("自动调节算法输出"+ (wd * 0.00000001).ToString(), true);
                //设置工作距离
                iSEM.SetWorkingDistance((float)(wd * 0.00000001));
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);
                //处理图片位置
                //File.Copy(focus_path + "\\fine\\" + wd.ToString() + ".tif", data_path + "\\" + ImageName);
            }
            else if (m_measureFile.MParam.FocusMode == 3)     //客户自动
            {
                //后期和客户对接接口
                List<string> filenames = new List<string>();
                String retfilename = wr.Img_Auto_Focus(filenames);
            }
            else        //蔡司自动对焦
            {
                iSEM.CmdAutoFocusCoarse();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
                iSEM.CmdAutoFocusFine();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
            }
            return true;
        }

        //执行自动对焦
        public bool ImageFocus1(Boolean Is_Stig)
        {
            if (m_measureFile.MParam.FocusMode == 1)//手动
            {
                if (DialogResult.Yes == MessageBox.Show("图像自动对焦已完成？", "确认消息", MessageBoxButtons.YesNo))
                {
                }
                else
                {
                    return false;
                }
            }
            else if (m_measureFile.MParam.FocusMode == 2)//自有自动
            {
                #region 执行蔡司自动对焦程序
                //服务地址
                string snumstr = @"http://192.168.1.101:8123";
                // 调用方法；只对焦不消像散
                if (Is_Stig)
                {
                    string focusstig = XmlRpcClient.autofocusstig(10, 3, 3, 3, 0.7, snumstr);
                    if (focusstig != "success")
                    {
                        log.Info("对焦失败" + focusstig , true);
                        return false;
                    }
                }
                else
                {
                    string onlyfocus = XmlRpcClient.autofocus(10, 3, 3, true, snumstr);
                    if (onlyfocus != "success")
                    {
                        return false;
                    }
                }
                #endregion
            }
            else if (m_measureFile.MParam.FocusMode == 3)     //客户自动
            {
                //后期和客户对接接口
                List<string> filenames = new List<string>();
                String retfilename = wr.Img_Auto_Focus(filenames);
            }
            else        //蔡司自动对焦
            {
                iSEM.CmdAutoFocusCoarse();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
                iSEM.CmdAutoFocusFine();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
            }
            return true;
        }

        //执行自动消像散
        public bool ImageStig()
        {
            if (m_measureFile.MParam.FocusMode == 1)//手动
            {
                if (DialogResult.Yes == MessageBox.Show("图像自动消像散已完成？", "确认消息", MessageBoxButtons.YesNo))
                {
                }
                else
                {
                    return false;
                }
            }
            else if (m_measureFile.MParam.FocusMode == 2)//自有自动
            {
                //郝工增加自动对焦算法
                //处理文件夹
                if (Directory.Exists(StigX_path))
                {
                    Directory.Delete(StigX_path, true);
                }
                Thread.Sleep(3000);
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(1000);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(1000);

                //再创建文件夹
                Directory.CreateDirectory(StigX_path);

                //1、对焦参数类，2、输出像散值
                int stigX = 0;

                //根据当前的stigX重新计算像散值

                float currentStigX = 0;// iSEM.GetAstigmatismX();
                                       //m_measureFile.MParam.AutoStigX.Step = 10; //像散的步长为10
                                       //m_measureFile.MParam.AutoStigX.UP = currentStigX - m_measureFile.MParam.AutoStigX.Step;
                                       //m_measureFile.MParam.AutoStigX.Down = currentStigX + m_measureFile.MParam.AutoStigX.Step;

                //设置工作距离
                iSEM.SetAstigmatismX((float)0);
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);

                //log.Info("修改消像散参数", true);
                AutoStig(m_measureFile.MParam.AutoStigX, out stigX);

                log.Info("自动消散算法输出X"+ (stigX * 0.01).ToString(), true);
                //设置工作距离
                iSEM.SetAstigmatismX((float)(stigX * 0.01));
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);
                //处理图片位置
                //File.Copy(focus_path + "\\fine\\" + wd.ToString() + ".tif", data_path + "\\" + ImageName);

                //处理文件夹
                if (Directory.Exists(StigY_path))
                {
                    Directory.Delete(StigY_path, true);
                }
                Thread.Sleep(3000);
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(1000);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(1000);

                //再创建文件夹
                Directory.CreateDirectory(StigY_path);

                //1、对焦参数类，2、输出像散值
                int stigY = 0;

                //根据当前的stigX重新计算像散值
                float currentStigY = 0;// iSEM.GetAstigmatismY();
                                       //m_measureFile.MParam.AutoStigY.Step = 10; //像散的步长为10
                                       //m_measureFile.MParam.AutoStigY.UP = m_measureFile.MParam.AutoStigY.;
                                       //m_measureFile.MParam.AutoStigY.Down = m_measureFile.MParam.AutoStigY.Step;

                iSEM.SetAstigmatismY((float)0);
                Thread.Sleep(2000);

                log.Info("修改消像散参数", true);
                AutoStig(m_measureFile.MParam.AutoStigY, out stigY);

                log.Info("自动消散算法输出Y" + (stigY * 0.01).ToString(), true);
                //设置工作距离
                iSEM.SetAstigmatismY((float)(stigY * 0.01));
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);
            }
            else if (m_measureFile.MParam.FocusMode == 3)     //客户自动
            {
                //后期和客户对接接口
                List<string> filenames = new List<string>();
                String retfilename = wr.Img_Auto_Focus(filenames);
            }
            else        //蔡司自动对焦
            {
                iSEM.CmdAutoFocusCoarse();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
                iSEM.CmdAutoFocusFine();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
            }
            return true;
        }

        //自动聚焦
        public bool AutoFocus(FocusParam a_param, out int a_nWd)
        {
            a_nWd = 0;
            float wd = iSEM.GetWorkingDistance();
            a_nWd = (int)Math.Ceiling(wd * 100000000 + 0.5);//获取当前的工作距离

            if (a_param == null)
            {
                log.Info("空参数", true);
                 return false;
            }

            string path = a_param.Path;
            if (!Directory.Exists(path))
            {
                log.Info("文件夹丢失", true);
                return false;
            }
            string path_coarse = a_param.Path + "\\Coarse";
            if (!Directory.Exists(path_coarse))
            {
                Directory.CreateDirectory(path_coarse);
            }
            string path_fine = a_param.Path + "\\Fine";
            if (!Directory.Exists(path_fine))
            {
                Directory.CreateDirectory(path_fine);
            }


            //1. 拍照
            //1.1， 粗拍照
            //1.1.1， 根据参数计算拍照次数
            double nUp = a_param.UP * 100.0 ;
            double nDown = a_param.Down * 100.0;
            double nStep = a_param.Step * 100.0;
            double nTimes = Math.Ceiling((nDown - nUp) / nStep + 0.5);
            log.Info("初调拍照次数=" + nTimes.ToString(), true);
            //SendMsg("粗对焦:最小值" + nUp.ToString() + ",最大值" + nDown.ToString() + ",步长" + nStep.ToString() + "拍照张数" + nTimes.ToString());
            
            //粗拍照
            for (int i = 0; i < nTimes; i++)
            {

                int cWd =(int) Math.Ceiling(nUp + i * nStep + 0.5);
                iSEM.SetWorkingDistance((float)(cWd * 0.00000001));
                arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() +"um");

                String fileName = path_coarse + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(fileName))
                {
                    return false;
                }
                //arg.State = true;
                //arg.Message = "自动对焦";
                //SendMsg("0-9");

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(3000);
            }

            //1.2， 选定细拍照的工作距离
            int CorWd = 510000;
            ChooseBest(path_coarse,out CorWd);

            if (CorWd == -1)
                CorWd = 510000;
            else
                a_nWd = CorWd;

            //SendMsg("粗选工作距离wd = " + a_nWd.ToString() );
            

            //1.3， 细拍照
            if ( (CorWd - a_param.Range * 100.0) <=0)
            {
                return false;
            }

            double nfUp = CorWd - a_param.Range * 100.0;
            double nfStep = a_param.fStep * 100.0;
            double nfTimes = Math.Ceiling((a_param.Range * 100.0 * 2) / nfStep + 0.5);


            //SendMsg("粗对焦:最小值" + nfUp.ToString()  + ",步长" + nfStep.ToString() + "拍照张数" + nfTimes.ToString());

            
            for (int i = 0; i < nfTimes; i++)
            {
                int cWd = (int)Math.Ceiling(nfUp + i * nfStep + 0.5);
                iSEM.SetWorkingDistance((float)(cWd * 0.00000001));
                arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time)+100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() + "um");

                String fileName = path_fine + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(fileName))
                {
                    return false;
                }
                //arg.State = true;
                //arg.Message = "自动对焦";
                //SendMsg("0-9");

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(2000);
            }

            int fineWd = CorWd;
            ChooseBest(path_fine, out fineWd);

            //SendMsg("wd fine max = " + fineWd.ToString());
            if (fineWd == -1)
                a_nWd = CorWd;
            else
                a_nWd = fineWd;

            //SendMsg("细选工作距离wd = " + a_nWd.ToString());
            //arg.State = true;
            //arg.Message = "自动对焦";
            //SendMsg(step_code);

            return true;

        }

        //自动聚焦1
        public bool AutoFocus1(FocusParam a_param, out int a_nWd)
        {
            a_nWd = 0;
            float wd = iSEM.GetWorkingDistance();
            a_nWd = (int)Math.Ceiling(wd * 100000000 + 0.5);//获取当前的工作距离

            if (a_param == null)
            {
                log.Info("空参数", true);
                return false;
            }

            string path = a_param.Path;
            if (!Directory.Exists(path))
            {
                log.Info("文件夹丢失", true);
                return false;
            }
            string path_coarse = a_param.Path + "\\Coarse";
            if (!Directory.Exists(path_coarse))
            {
                Directory.CreateDirectory(path_coarse);
            }
            string path_fine = a_param.Path + "\\Fine";
            if (!Directory.Exists(path_fine))
            {
                Directory.CreateDirectory(path_fine);
            }


            //1. 拍照
            //1.1， 粗拍照
            //1.1.1， 根据参数计算拍照次数
            double nUp = a_param.UP * 100.0;
            double nDown = a_param.Down * 100.0;
            double nStep = a_param.Step * 100.0;
            double nTimes = Math.Ceiling((nDown - nUp) / nStep + 0.5);
            log.Info("初调拍照次数=" + nTimes.ToString(), true);
            //SendMsg("粗对焦:最小值" + nUp.ToString() + ",最大值" + nDown.ToString() + ",步长" + nStep.ToString() + "拍照张数" + nTimes.ToString());

            //粗拍照
            for (int i = 0; i < nTimes; i++)
            {

                int cWd = (int)Math.Ceiling(nUp + i * nStep + 0.5);
                iSEM.SetWorkingDistance((float)(cWd * 0.00000001));
                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) + 50);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() +"um");

                String fileName = path_coarse + "\\" + cWd.ToString() + ".tif";
                //arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage1(fileName))
                {
                    return false;
                }
                //arg.State = true;
                //arg.Message = "自动对焦";
                //SendMsg(step_code);

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(3000);
            }

            //1.2， 选定细拍照的工作距离
            int CorWd = (int)Math.Ceiling(wd * 100000000 + 0.5);
            ChooseBest(path_coarse, out CorWd);

            if (CorWd == -1)
                CorWd = (int)Math.Ceiling(wd * 100000000 + 0.5);
            else
                a_nWd = CorWd;

            //SendMsg("粗选工作距离wd = " + a_nWd.ToString() );

            //1.3， 细拍照
            if ((CorWd - a_param.Range * 100.0) <= 0)
            {
                return false;
            }

            double nfUp = CorWd - a_param.Range * 100.0;
            double nfStep = a_param.fStep * 100.0;
            double nfTimes = Math.Ceiling((a_param.Range * 100.0 * 2) / nfStep + 0.5);


            //SendMsg("粗对焦:最小值" + nfUp.ToString()  + ",步长" + nfStep.ToString() + "拍照张数" + nfTimes.ToString());


            for (int i = 0; i < nfTimes; i++)
            {
                int cWd = (int)Math.Ceiling(nfUp + i * nfStep + 0.5);
                iSEM.SetWorkingDistance((float)(cWd * 0.00000001));
                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) + 1000);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() + "um");

                String fileName = path_fine + "\\" + cWd.ToString() + ".tif";
                //arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage1(fileName))
                {
                    return false;
                }
                //arg.State = true;
                //arg.Message = "自动对焦";
                //SendMsg(step_code);

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(2000);
            }

            int fineWd = CorWd;
            ChooseBest(path_fine, out fineWd);

            //SendMsg("wd fine max = " + fineWd.ToString());
            if (fineWd == -1)
                a_nWd = CorWd;
            else
                a_nWd = fineWd;

            //SendMsg("细选工作距离wd = " + a_nWd.ToString());
            //arg.State = true;
            //arg.Message = "自动对焦";
            //SendMsg("0-9");

            return true;

        }

        //自动消像散 AutoStig
        public bool AutoStig(FocusParam a_param, out int a_nWd)
        {
            a_nWd = 0;
            float wd = 0;
            if (a_param.TYPE == 2)
            {
                wd = iSEM.GetAstigmatismX();
            }
            else if (a_param.TYPE == 3)
            {
                wd = iSEM.GetAstigmatismY();
            }
            else
            {
                log.Info("自动消像散参数设置有误", true);
                return false;
            }
            
            a_nWd = (int)Math.Ceiling(wd * 100 + 0.5);//获取当前的工作距离

            if (a_param == null)
            {
                log.Info("空参数", true);
                return false;
            }

            string path = a_param.Path;
            if (!Directory.Exists(path))
            {
                log.Error("文件夹丢失", false);
                return false;
            }
            string path_coarse = a_param.Path + "\\Coarse";
            if (!Directory.Exists(path_coarse))
            {
                Directory.CreateDirectory(path_coarse);
            }
            string path_fine = a_param.Path + "\\Fine";
            if (!Directory.Exists(path_fine))
            {
                Directory.CreateDirectory(path_fine);
            }


            //1. 拍照
            //1.1， 粗拍照
            //1.1.1， 根据参数计算拍照次数
            double nUp = a_param.UP * 100.0;
            double nDown = a_param.Down * 100.0;
            double nStep = a_param.Step * 100.0;
            double nTimes = Math.Ceiling((nDown - nUp) / nStep + 0.5);
            log.Info("初调拍照次数=" + nTimes.ToString(), true);
            //SendMsg("粗对焦:最小值" + nUp.ToString() + ",最大值" + nDown.ToString() + ",步长" + nStep.ToString() + "拍照张数" + nTimes.ToString());

            //粗拍照
            for (int i = 0; i < nTimes; i++)
            {

                int cWd = (int)Math.Ceiling(nUp + i * nStep + 0.5);

                if (a_param.TYPE == 2)
                {
                    iSEM.SetAstigmatismX((float)(cWd * 0.01));
                }
                else if (a_param.TYPE == 3)
                {
                    iSEM.SetAstigmatismY((float)(cWd * 0.01));
                }
                else
                {
                    log.Info("自动消像散参数设置有误", true);
                    return false;
                }

                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() +"um");

                String fileName = path_coarse + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(fileName))
                {
                    return false;
                }
                arg.State = true;
                arg.Message = "自动像散";
                SendMsg("0-8");

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(3000);
            }

            //1.2， 选定细拍照的工作距离
            int CorWd;
            ChooseBest(path_coarse, out CorWd);

            if (CorWd == -1)
            {
                a_nWd = 0;
            }
            else
            {
                a_nWd = CorWd;
            }
            //SendMsg("粗选工作距离wd = " + a_nWd.ToString() );



            //1.3， 细拍照
            if ((CorWd - a_param.Range * 100.0) <= -10000)
            {
                return false;
            }

            double nfUp = 0;
            if (a_param.Range >= 0)
                nfUp = CorWd - a_param.Range * 100.0;
            else
                nfUp = CorWd + a_param.Range * 100.0;

            double nfStep = a_param.fStep * 100.0;
            double nfTimes = Math.Ceiling((a_param.Range * 100.0 * 2) / nfStep + 0.5);


            //SendMsg("粗对焦:最小值" + nfUp.ToString()  + ",步长" + nfStep.ToString() + "拍照张数" + nfTimes.ToString());


            for (int i = 0; i < nfTimes; i++)
            {
                int cWd = (int)Math.Ceiling(nfUp + i * nfStep + 0.5);
                if (a_param.TYPE == 2)
                {
                    iSEM.SetAstigmatismX((float)(cWd * 0.01));
                }
                else if (a_param.TYPE == 3)
                {
                    iSEM.SetAstigmatismY((float)(cWd * 0.01));
                }
                else
                {
                    log.Info("自动消像散参数设置有误", true);
                    return false;
                }
                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() + "um");

                String fileName = path_fine + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(fileName))
                {
                    return false;
                }
                arg.State = true;
                arg.Message = "自动像散";
                SendMsg("0-8");

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(2000);
            }

            int fineWd = CorWd;
            ChooseBest(path_fine, out fineWd);

            //SendMsg("wd fine max = " + fineWd.ToString());
            if(fineWd == -1)
                a_nWd = CorWd;
            else
                a_nWd = fineWd;

            //SendMsg("细选工作距离wd = " + a_nWd.ToString());

            //arg.State = true;
            //arg.Message = "自动像散";
            //SendMsg(step_code);

            return true;

        }

        //执行自动消像散1
        public bool ImageStig1()
        {
            if (m_measureFile.MParam.FocusMode == 1)//手动
            {
                if (DialogResult.Yes == MessageBox.Show("图像自动消像散已完成？", "确认消息", MessageBoxButtons.YesNo))
                {
                }
                else
                {
                    return false;
                }
            }
            else if (m_measureFile.MParam.FocusMode == 2)//自有自动
            {
                //郝工增加自动对焦算法
                //处理文件夹
                if (Directory.Exists(StigX_path))
                {
                    Directory.Delete(StigX_path, true);
                }
                Thread.Sleep(3000);
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(200);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(200);

                //再创建文件夹
                Directory.CreateDirectory(StigX_path);

                //1、对焦参数类，2、输出像散值
                int stigX = 0;

                //根据当前的stigX重新计算像散值

                float currentStigX = 0;// iSEM.GetAstigmatismX();
                                       //m_MsParam.AutoStigX.Step = 10; //像散的步长为10
                                       //m_MsParam.AutoStigX.UP = currentStigX - m_MsParam.AutoStigX.Step;
                                       //m_MsParam.AutoStigX.Down = currentStigX + m_MsParam.AutoStigX.Step;

                //设置工作距离
                currentStigX = iSEM.GetAstigmatismX();
                Thread.Sleep(1000);

                FocusParam pFocus = new FocusParam();
                pFocus = m_measureFile.MParam.AutoStigX;

                float old_up = m_measureFile.MParam.AutoStigX.UP;
                float old_down = m_measureFile.MParam.AutoStigX.Down;

                float setvalue = m_measureFile.MParam.AutoStigX.UP;
                pFocus.UP = currentStigX - setvalue;
                pFocus.Down = currentStigX + setvalue;
                //m_measureFile.MParam.AutoStigX.Step = 1;
                //m_measureFile.MParam.AutoStigX.Range = (float)0.5;
                //m_measureFile.MParam.AutoStigX.fStep = (float)0.1;

                log.Info("消像散参数: up = "+pFocus.UP+",down = " + pFocus.Down+ ",step =" + pFocus.Step + ",rang ="+ pFocus.Range + ",fstep = " + pFocus.fStep, true);

                //log.Info("修改消像散参数", true);
                AutoStig1(pFocus, out stigX);

                m_measureFile.MParam.AutoStigX.UP = old_up;
                m_measureFile.MParam.AutoStigX.Down = old_down;

                log.Info("自动消散算法输出X" + (stigX * 0.01).ToString(), true);
                //设置工作距离
                iSEM.SetAstigmatismX((float)(stigX * 0.01));
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);
                //处理图片位置
                //File.Copy(focus_path + "\\fine\\" + wd.ToString() + ".tif", data_path + "\\" + ImageName);

                //处理文件夹
                if (Directory.Exists(StigY_path))
                {
                    Directory.Delete(StigY_path, true);
                }
                Thread.Sleep(3000);
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(200);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(200);

                //再创建文件夹
                Directory.CreateDirectory(StigY_path);

                //1、对焦参数类，2、输出像散值
                int stigY = 0;

                //根据当前的stigX重新计算像散值
                float currentStigY = 0;// iSEM.GetAstigmatismY();
                                       //m_MsParam.AutoStigY.Step = 10; //像散的步长为10
                                       //m_MsParam.AutoStigY.UP = m_MsParam.AutoStigY.;
                                       //m_MsParam.AutoStigY.Down = m_MsParam.AutoStigY.Step;

                currentStigY = iSEM.GetAstigmatismY();
                Thread.Sleep(1000);

                //m_measureFile.MParam.AutoStigY.UP = currentStigY - setvalue;
                //m_measureFile.MParam.AutoStigY.Down = currentStigY + setvalue;
                //m_measureFile.MParam.AutoStigY.Step = 1;
                //m_measureFile.MParam.AutoStigY.Range = (float)0.5;
                //m_measureFile.MParam.AutoStigY.fStep = (float)0.1;

                FocusParam pFocusY = new FocusParam();
                pFocusY = m_measureFile.MParam.AutoStigY;

                float old_upY = m_measureFile.MParam.AutoStigY.UP;
                float old_downY = m_measureFile.MParam.AutoStigY.Down;

                //float setvalue = m_measureFile.MParam.AutoStigX.UP;
                pFocusY.UP = currentStigY - setvalue;
                pFocusY.Down = currentStigY + setvalue;

                log.Info("消像散参数: up = " + pFocusY.UP + ",down = " + pFocusY.Down + ",step =" + pFocusY.Step + ",rang =" + pFocusY.Range + ",fstep = " + pFocusY.fStep, true);
                AutoStig1(pFocusY, out stigY);

                m_measureFile.MParam.AutoStigY.UP = old_upY;
                m_measureFile.MParam.AutoStigY.Down = old_downY;

                log.Info("自动消散算法输出Y" + (stigY * 0.01).ToString(), true);
                //设置工作距离
                iSEM.SetAstigmatismY((float)(stigY * 0.01));
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);
            }
            else if (m_measureFile.MParam.FocusMode == 3)     //客户自动
            {
                //后期和客户对接接口
                List<string> filenames = new List<string>();
                String retfilename = wr.Img_Auto_Focus(filenames);
            }
            else        //蔡司自动对焦
            {
                iSEM.CmdAutoFocusCoarse();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
                iSEM.CmdAutoFocusFine();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
            }
            return true;
        }

        //自动消像散 AutoStig1
        public bool AutoStig1(FocusParam a_param, out int a_nWd)
        {
            a_nWd = 0;
            float wd = 0;
            if (a_param.TYPE == 2)
            {
                wd = iSEM.GetAstigmatismX();
            }
            else if (a_param.TYPE == 3)
            {
                wd = iSEM.GetAstigmatismY();
            }
            else
            {
                log.Info("自动消像散参数设置有误", true);
                return false;
            }

            a_nWd = (int)Math.Ceiling(wd * 100 + 0.5);//获取当前的工作距离

            if (a_param == null)
            {
                log.Info("空参数", true);
                return false;
            }

            string path = a_param.Path;
            if (!Directory.Exists(path))
            {
                log.Info("文件夹丢失", true);
                return false;
            }
            string path_coarse = a_param.Path + "\\Coarse";
            if (!Directory.Exists(path_coarse))
            {
                Directory.CreateDirectory(path_coarse);
            }
            string path_fine = a_param.Path + "\\Fine";
            if (!Directory.Exists(path_fine))
            {
                Directory.CreateDirectory(path_fine);
            }


            //1. 拍照
            //1.1， 粗拍照
            //1.1.1， 根据参数计算拍照次数
            double nUp = a_param.UP * 100.0;
            double nDown = a_param.Down * 100.0;
            double nStep = a_param.Step * 100.0;
            double nTimes = Math.Ceiling((nDown - nUp) / nStep + 0.5);
            log.Info("初调拍照次数=" + nTimes.ToString(), true);
            //SendMsg("粗对焦:最小值" + nUp.ToString() + ",最大值" + nDown.ToString() + ",步长" + nStep.ToString() + "拍照张数" + nTimes.ToString());

            //粗拍照
            for (int i = 0; i < nTimes; i++)
            {

                int cWd = (int)Math.Ceiling(nUp + i * nStep + 0.5);

                if (a_param.TYPE == 2)
                {
                    iSEM.SetAstigmatismX((float)(cWd * 0.01));
                }
                else if (a_param.TYPE == 3)
                {
                    iSEM.SetAstigmatismY((float)(cWd * 0.01));
                }
                else
                {
                    log.Info("自动消像散参数设置有误", true);
                    return false;
                }

                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) + 100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() +"um");

                String fileName = path_coarse + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage1(fileName))
                {
                    return false;
                }
                //arg.State = true;
                //arg.Message = "自动像散";
                //SendMsg(step_code);

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(3000);
            }

            //1.2， 选定细拍照的工作距离
            int CorWd;
            ChooseBest(path_coarse, out CorWd);

            if (CorWd == -1)
            {
                a_nWd = 0;
            }
            else
            {
                a_nWd = CorWd;
            }
            //SendMsg("粗选工作距离wd = " + a_nWd.ToString() );



            //1.3， 细拍照
            if ((CorWd - a_param.Range * 100.0) <= -10000)
            {
                return false;
            }

            double nfUp = 0;
            if (a_param.Range >= 0)
                nfUp = CorWd - a_param.Range * 100.0;
            else
                nfUp = CorWd + a_param.Range * 100.0;

            double nfStep = a_param.fStep * 100.0;
            double nfTimes = Math.Ceiling((a_param.Range * 100.0 * 2) / nfStep + 0.5);


            //SendMsg("粗对焦:最小值" + nfUp.ToString()  + ",步长" + nfStep.ToString() + "拍照张数" + nfTimes.ToString());


            for (int i = 0; i < nfTimes; i++)
            {
                int cWd = (int)Math.Ceiling(nfUp + i * nfStep + 0.5);
                if (a_param.TYPE == 2)
                {
                    iSEM.SetAstigmatismX((float)(cWd * 0.01));
                }
                else if (a_param.TYPE == 3)
                {
                    iSEM.SetAstigmatismY((float)(cWd * 0.01));
                }
                else
                {
                    log.Info("自动消像散参数设置有误", true);
                    return false;
                }
                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) + 100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() + "um");

                String fileName = path_fine + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage1(fileName))
                {
                    return false;
                }
                //arg.State = true;
                //arg.Message = "自动像散";
                //SendMsg(step_code);

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(2000);
            }

            int fineWd = CorWd;
            ChooseBest(path_fine, out fineWd);

            //SendMsg("wd fine max = " + fineWd.ToString());
            if (fineWd == -1)
                a_nWd = CorWd;
            else
                a_nWd = fineWd;

            //SendMsg("细选工作距离wd = " + a_nWd.ToString());

            //arg.State = true;
            //arg.Message = "自动像散";
            //SendMsg("0-9");

            return true;

        }

        //自动FIB对焦        AutoFIBFocus
        public bool AutoFIBFocus(FocusParam a_param, out int a_nWd, String step_code)
        {
            a_nWd = 0;
            float wd = 0;
            if (a_param.TYPE == 4)
            {
                wd = iSEM.GetFIBObjectivePotential();
            }
            else
            {
                log.Error("FIB自动聚焦参数设置有误", false);
                return false;
            }

            a_nWd = (int)Math.Ceiling(wd * 100 + 0.5);//获取当前的工作距离

            if (a_param == null)
            {
                log.Error("空参数", false);
                return false;
            }

            string path = a_param.Path;
            if (!Directory.Exists(path))
            {
                log.Error("文件夹丢失", false);
                return false;
            }
            string path_coarse = a_param.Path + "\\Coarse";
            if (!Directory.Exists(path_coarse))
            {
                Directory.CreateDirectory(path_coarse);
            }
            string path_fine = a_param.Path + "\\Fine";
            if (!Directory.Exists(path_fine))
            {
                Directory.CreateDirectory(path_fine);
            }


            //1. 拍照
            //1.1， 粗拍照
            //1.1.1， 根据参数计算拍照次数
            double nUp = a_param.UP * 100.0;
            double nDown = a_param.Down * 100.0;
            double nStep = a_param.Step * 100.0;
            double nTimes = Math.Ceiling((nDown - nUp) / nStep + 0.5);
            log.Info("初调拍照次数=" + nTimes.ToString(), true);
            //SendMsg("粗对焦:最小值" + nUp.ToString() + ",最大值" + nDown.ToString() + ",步长" + nStep.ToString() + "拍照张数" + nTimes.ToString());

            //粗拍照
            for (int i = 0; i < nTimes; i++)
            {

                int cWd = (int)Math.Ceiling(nUp + i * nStep + 0.5);

                if (a_param.TYPE == 4)
                {
                    iSEM.SetFIBObjectivePotential((float)(cWd * 0.01));
                }
                else
                {
                    log.Error("FIB对焦参数设置有误，对焦类型错", false);
                    return false;
                }

                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() +"um");

                String fileName = path_coarse + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(fileName))
                {
                    return false;
                }
                arg.State = true;
                arg.Message = "FIB自动对焦";
                SendMsg(step_code);

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(3000);
            }

            //1.2， 选定细拍照的工作距离
            int CorWd;
            ChooseBest(path_coarse, out CorWd);

            a_nWd = CorWd;

            //SendMsg("粗选工作距离wd = " + a_nWd.ToString() );


            //1.3， 细拍照
            if ((CorWd - a_param.Range * 100.0) <0)
            {
                return false;
            }

            double nfUp = CorWd - a_param.Range * 100.0;
            double nfStep = a_param.fStep * 100.0;
            double nfTimes = Math.Ceiling((a_param.Range * 100.0 * 2) / nfStep + 0.5);


            //SendMsg("粗对焦:最小值" + nfUp.ToString()  + ",步长" + nfStep.ToString() + "拍照张数" + nfTimes.ToString());


            for (int i = 0; i < nfTimes; i++)
            {
                int cWd = (int)Math.Ceiling(nfUp + i * nfStep + 0.5);
                if (a_param.TYPE == 4)
                {
                    iSEM.SetFIBObjectivePotential((float)(cWd * 0.01));
                }
                else
                {
                    log.Error("自动消像散参数设置有误", false);
                    return false;
                }
                //arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(Convert.ToInt32(cycle_time) +100);

                int swd = cWd / 100;
                //SendMsg("wd = " + swd.ToString() + "um");

                String fileName = path_fine + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(fileName))
                {
                    return false;
                }
                arg.State = true;
                arg.Message = "FIB自动对焦";
                SendMsg(step_code);

                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
                //Thread.Sleep(2000);
            }

            int fineWd;
            ChooseBest(path_fine, out fineWd);

            //SendMsg("wd fine max = " + fineWd.ToString());

            a_nWd = fineWd;

            //SendMsg("细选工作距离wd = " + a_nWd.ToString());

            return true;

        }

        //LoG算子计算
        private double LoGMean(string a_strImgPath)
        {
            //读入Img文件
            if (!File.Exists(a_strImgPath))
            {
                return 0;
            }

            Mat src, gray_src;
            int kernel_size = 3;

            src = Cv2.ImRead(a_strImgPath);
            gray_src = new Mat();

            src.CvtColor(ColorConversionCodes.BGR2GRAY);

            Mat kernel = Cv2.GetStructuringElement(MorphShapes.Cross, new OpenCvSharp.Size(10, 10));
            Cv2.MorphologyEx(src, src, MorphTypes.Close, kernel);

            Cv2.GaussianBlur(src, src, new OpenCvSharp.Size(3, 3), 0, 0);
            Cv2.Laplacian(src, src, MatType.CV_8UC3, kernel_size);
            Cv2.ConvertScaleAbs(src, src);

            //图像的平均灰度

            double meanValue = 0.0;
            meanValue = Cv2.Mean(src)[0];
            return meanValue;
        }

        //梯度计算
        private double Tenengrad(string a_strImgPath)
        {
            //读入Img文件
            if (!File.Exists(a_strImgPath))
            {
                return 0;
            }

            Mat src;
            src = Cv2.ImRead(a_strImgPath);

            src.CvtColor(ColorConversionCodes.BGR2GRAY);

            Mat kernel = Cv2.GetStructuringElement(MorphShapes.Cross, new OpenCvSharp.Size(10, 10));
            Cv2.MorphologyEx(src, src, MorphTypes.Close, kernel);

            Cv2.GaussianBlur(src, src, new OpenCvSharp.Size(3, 3), 0, 0);
            Cv2.Sobel(src, src, MatType.CV_8UC1, 1, 1);
            //图像的平均灰度
            double meanValue = 0.0;
            meanValue = Cv2.Mean(src)[0];
            return meanValue;
        }

        //梯度计算
        private double TTgrad(string a_strImgPath)
        {
            //读入Img文件
            if (!File.Exists(a_strImgPath))
            {
                return 0;
            }

            Mat src;
            src = Cv2.ImRead(a_strImgPath);

            src.CvtColor(ColorConversionCodes.BGR2GRAY);

            Mat kernel = Cv2.GetStructuringElement(MorphShapes.Cross, new OpenCvSharp.Size(10, 10));
            Cv2.MorphologyEx(src, src, MorphTypes.Close, kernel);

            Mat scalex = new Mat();
            Mat scaley = new Mat();

            Cv2.Scharr(src, src, src.Depth(), 1, 0);
            Cv2.ConvertScaleAbs(src, scalex);

            Cv2.Scharr(src, src, src.Depth(), 0, 1);
            Cv2.ConvertScaleAbs(src, scaley);

            Cv2.AddWeighted(scalex, 0.5, scaley, 0.5, 0, src);

            //图像的平均灰度
            double meanValue = 0.0;
            meanValue = Cv2.Mean(src)[0];
            return meanValue;
        }

        //三选二算法
        private bool ChooseBest(string a_strImgPath, out int a_nWd)
        {
            a_nWd = -1;

            var files = Directory.GetFiles(a_strImgPath, "*.tif");
            float[] values = new float[files.Length];


            double smax1 = LoGMean(files[0]);
            int wdmax1 = int.Parse(System.IO.Path.GetFileNameWithoutExtension(files[0]));

            double smax2 = Tenengrad(files[0]);
            int wdmax2 = wdmax1;

            double smax3 = TTgrad(files[0]);
            int wdmax3 = wdmax1;



            int x = 0;
            foreach (var file in files)
            {

                int wd = int.Parse(System.IO.Path.GetFileNameWithoutExtension(file));
                double svalue1 = LoGMean(file);
                double svalue2 = Tenengrad(file);
                double svalue3 = TTgrad(file);


                if (smax1 < svalue1)
                {
                    smax1 = svalue1;
                    wdmax1 = wd;
                }

                if (smax2 < svalue2)
                {
                    smax2 = svalue2;
                    wdmax2 = wd;
                }

                if (smax3 < svalue3)
                {
                    smax3 = svalue3;
                    wdmax3 = wd;
                }

                x++;
            }

            //SendMsg("LoG = " + wdmax1.ToString() + "，梯度 = " + wdmax2.ToString() + "，滤波 = " + wdmax3.ToString());


            if (wdmax1 == wdmax2 || wdmax1 == wdmax3)
            {
                a_nWd = wdmax1;
                //SendMsg("焦距 = " + wdmax1.ToString());
            }
            else if (wdmax1 == wdmax2 || wdmax2 == wdmax3)
            {
                a_nWd = wdmax2;
                //SendMsg("焦距 = " + wdmax2.ToString());
            }
            else if (wdmax3 == wdmax2 || wdmax1 == wdmax3)
            {
                a_nWd = wdmax3;
                //SendMsg("焦距 = " + wdmax3.ToString());
            }
            else
            {
                //SendMsg("对焦失败。");
                return false;
            }

            return true;
        }

        //移动到像素位置，这里要靠移动样品台实现，当位移量小于3um时，不予移动
        bool MoveToPixByMoveStage(float xc, float yc)
        {
            //单位是m/pix
            float XpixSize = iSEM.GetPixelSize();
            log.Info("X像素尺寸=" + XpixSize.ToString() + "m/pixel", true);
            float YpixSize = iSEM.GetPixelSize();///(float)m_measureFile.MParam.PixelSizeCor);
            log.Info("Y像素尺寸=" + YpixSize.ToString() + "m/pixel", true);

            Thread.Sleep(500);
            //0:width, 1:height
            int[] imageSize = iSEM.GetImageStore();

            int width = imageSize[0] / 2;
            int height = imageSize[1] / 2;

            log.Info("目标像素是(" + xc.ToString() + "," + yc.ToString() + ")", true);
            log.Info("中心像素是(" + width.ToString() + "," + height.ToString() + ")", true);

            float deltX = (xc - (float)width) * XpixSize;
            float deltY = (yc - (float)height) * YpixSize;

            log.Info("x位移量 = " + deltX.ToString() + "m", true);
            log.Info("y位移量 = " + deltY.ToString() + "m", true);

            float xpCur = iSEM.GetStageAtX();
            float ypCur = iSEM.GetStageAtY();

            log.Info("当前位置（" + xpCur.ToString() + "," + ypCur.ToString() + "),单位m", true);

            float xpNew = xpCur - deltX;
            float ypNew = ypCur + deltY;

            log.Info("目标位置（" + xpNew.ToString() + "," + ypNew.ToString() + "),单位m", true);

            //计算光束偏移值：
            //if (deltX >= 0.000003 || deltX <= 0.000003)//大于3um使用移动样品台实现
            {
                log.Info("X方向移动样品台", true);

                if (!iSEM.SetStageGotoX(xpNew))
                {
                    return false;
                }

                //判断是否移动完成
                while (true)
                {
                    Thread.Sleep(5000);
                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }               
            }          

            //if (deltY >= 0.000003 || deltY <= -0.000003)//大于3um使用移动样品台实现
            {
                log.Info("Y方向移动样品台", true);

                if (!iSEM.SetStageGotoY(ypNew))
                {
                    return false;
                }

                //判断是否移动完成
                while (true)
                {
                    Thread.Sleep(5000);
                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }                
            }

            return true;
        }

        //移动到像素位置
        bool MoveToPix(float xc, float yc)
        {
            //单位是m/pix
            float XpixSize = iSEM.GetPixelSize();

            log.Info("X像素尺寸=" + XpixSize.ToString() + "m/pixel",true);
            float YpixSize = (XpixSize/(float)m_measureFile.MParam.PixelSizeCor);
            log.Info("Y像素尺寸=" + YpixSize.ToString() + "m/pixel", true);

            Thread.Sleep(200);
            //0:width, 1:height
            int[] imageSize = iSEM.GetImageStore();

            int width = imageSize[0]/2;
            int height = imageSize[1]/2;

            log.Info("目标像素是(" + xc.ToString()+ ","+ yc.ToString() + ")", true);
            log.Info("中心像素是(" + width.ToString() + "," + height.ToString() + ")", true);

            float deltX = (xc - (float)width) * XpixSize;
            float deltY = (yc - (float)height) * YpixSize;

            log.Info("x位移量 = " + deltX.ToString() + "m", true);
            log.Info("y位移量 = " + deltY.ToString() + "m", true);

            float xpCur = iSEM.GetStageAtX();
            Thread.Sleep(200);
            float ypCur = iSEM.GetStageAtY();

            log.Info("当前位置（" + xpCur.ToString()+ "," + ypCur.ToString() + "),单位m", true);

            float xpNew = xpCur - deltX;
            float ypNew = ypCur + deltY;

            log.Info("目标位置（" + xpNew.ToString() + "," + ypNew.ToString() + "),单位m", true);

            //计算最大偏移量
            float beamXCur = iSEM.GetBeamShiftX();//单位是%
            Thread.Sleep(200);
            iSEM.SetBeamShiftX(100);
            Thread.Sleep(200);
            float beamXMax = iSEM.GetBeamOffsetX();//单位是m
            Thread.Sleep(200);
            iSEM.SetBeamShiftX(beamXCur);
            Thread.Sleep(200);
            //计算光束偏移值：
            float beamX = iSEM.GetBeamOffsetX();
            log.Info("当前X方向光束偏移量=" + beamX.ToString() + "m", true);

            beamX = (-deltX + beamX);
            log.Info("X方向光束偏移量应为=" + beamX.ToString() + "m", true);

            if( ((beamX <= beamXMax) && (beamX >=0)) ||
                ((beamX >= -beamXMax)&& (beamX < 0)))
            {
                log.Info("X方向移动光束", true);
                float beamXShift = beamX * 100 / beamXMax;
                log.Info("X方向光束偏移量应为=" + beamXShift.ToString() + "%", true);
                if (!iSEM.SetBeamShiftX(beamXShift))
                //if (!iSEM.SetBeamOffsetX(beamX))
                    {
                    log.Info("X方向光束偏移量" + beamX.ToString() + "m失败", true);
                    return false;
                }
            }
            else if(deltX > 0.000003 || deltX < -0.000003)//大于3um使用移动样品台实现
            {
                log.Info("X方向移动样品台", true);

                if (!iSEM.SetStageGotoX(xpNew))
                {
                    return false;
                }

                //判断是否移动完成
                while (true)
                {
                    Thread.Sleep(4000);
                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }                
            }           

            float beamY = iSEM.GetBeamOffsetY();
            log.Info("当前Y方向光束偏移量=" + beamY.ToString() + "m", true);

            beamY = (-deltY + beamY);
            log.Info("Y方向光束偏移量应为=" + beamY.ToString() + "m", true);

            //计算最大偏移量
            float beamYCur = iSEM.GetBeamShiftY();//单位是%
            Thread.Sleep(200);
            iSEM.SetBeamShiftY(100);
            Thread.Sleep(200);
            float beamYMax = iSEM.GetBeamOffsetY();//单位是m
            Thread.Sleep(200);
            iSEM.SetBeamShiftY(beamYCur);
            Thread.Sleep(200);
            if (((beamY <= beamYMax) && (beamY >= 0)) ||
                ((beamY >= -beamYMax) && (beamY < 0)))
            {
                log.Info("Y方向移动光束", true);
                float beamYShift = beamY * 100 / beamYMax;
                log.Info("Y方向光束偏移量" + beamYShift.ToString() + "%", true);
                //if(!iSEM.SetBeamOffsetY(beamY))
                if (!iSEM.SetBeamShiftY(beamYShift))
                {
                    log.Info("Y方向光束偏移量" + beamY.ToString() + "m失败", true);
                    return false;
                }
            }
            else if (deltY > 0.000003 || deltY < -0.000003)//大于3um使用移动样品台实现
            {
                log.Info("Y方向移动样品台", true);

                if (!iSEM.SetStageGotoY(ypNew))
                {
                    return false;
                }

                //判断是否移动完成
                while (true)
                {
                    Thread.Sleep(4000);
                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //arg.Message = "移动到新x" + xpNew.ToString() + "位置失败";
                //arg.State = true;
                //SendMsg("1-7");
            }

            return true;
        }


        //自动亮度对比度调节
        //自动亮度对比度
        public bool AutoBC(String step)
        {

            arg.Message = "自动亮度对比度";
            arg.State = true;
            SendMsg("1-10");
            iSEM.SetAutoBright(100);

            iSEM.SetAutoContrast(100);
            //log.Info("FIB模式自动亮度目标51.5，自动对比度目标35.", true);

            if (!iSEM.SetAutoVideoBrightnessAndContrast())
            {
                log.Info("开始设置自动亮度、对比度失败，程序退出。", true);
                return false;
            }
            Thread.Sleep(5000);

            int i = 0;
            float bright = iSEM.GetBrightness();
            float contrast = iSEM.GetContrast();
            //最多调节30s，30s没调节好，认为调节失败
            for (i = 0; i < 5; i++)
            {
                bright = iSEM.GetBrightness();
                contrast = iSEM.GetContrast();

                if ((bright >= 40 && bright <= 60)
                    && (contrast >= 35 && contrast <= 40))
                    break;

                Thread.Sleep(5000);
            }

            bright = iSEM.GetBrightness();
            contrast = iSEM.GetContrast();

            if (((bright < 40 || bright > 60) || (contrast < 35 && contrast > 40))
                && i == 5)
            {
                log.Info("亮度对比度调节时间过长", true);
                return false;
            }

            iSEM.SetAutoBright(100);
            iSEM.SetAutoContrast(100);
            //log.Info("SEM模式自动亮度目标50，自动对比度目标30.", true);

            return true;
        }

        //执行FIB自动对焦，FIBFocus
        //执行自动消像散
        public bool FIBFocus(String step_code)
        {
            if (m_measureFile.MParam.FocusMode == 1)//手动
            {
                if (DialogResult.Yes == MessageBox.Show("FIB图像对焦已完成？", "确认消息", MessageBoxButtons.YesNo))
                {
                }
                else
                {
                    return false;
                }
            }
            else if (m_measureFile.MParam.FocusMode == 2)//自有自动
            {
                //郝工增加自动对焦算法
                //处理文件夹
                if (Directory.Exists(FIBfocus_path))
                {
                    Directory.Delete(FIBfocus_path, true);
                }
                Thread.Sleep(3000);
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(1000);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(1000);

                //再创建文件夹
                Directory.CreateDirectory(FIBfocus_path);

                //1、对焦参数类，2、输出对焦值
                int FIBFocus = 0;

                //根据当前的stigX重新计算像散值
                float currentFIBFocus = iSEM.GetFIBObjectivePotential();
                //m_measureFile.MParam.FIBFocus.Step = 10; //像散的步长为10
                m_measureFile.MParam.FIBFocus.UP = currentFIBFocus - m_measureFile.MParam.FIBFocus.Step;
                m_measureFile.MParam.FIBFocus.Down = currentFIBFocus + m_measureFile.MParam.FIBFocus.Step;

                log.Info("修改FIB自动对焦参数", true);
                AutoFIBFocus(m_measureFile.MParam.FIBFocus, out FIBFocus, step_code);

                //log.Info("算法输出"+ wd.ToString(), true);
                //设置工作距离
                iSEM.SetFIBObjectivePotential((float)(FIBFocus * 0.01));
                //设置完工作距离后必须延迟5秒
                Thread.Sleep(5000);
                //处理图片位置
                //File.Copy(focus_path + "\\fine\\" + wd.ToString() + ".tif", data_path + "\\" + ImageName);               
            }
            else if (m_measureFile.MParam.FocusMode == 3)     //客户自动
            {
                //后期和客户对接接口
                List<string> filenames = new List<string>();
                String retfilename = wr.Img_Auto_Focus(filenames);
            }
            else        //蔡司自动对焦
            {
                iSEM.CmdAutoFocusCoarse();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
                iSEM.CmdAutoFocusFine();
                while (true)
                {
                    Thread.Sleep(10000);

                    if (0 == iSEM.GetAutoFunction())
                    {
                        break;
                    }
                }
            }
            return true;
        }

        /// 图像拉直算法
        /// </summary>
        /// <param name="Slope">倾斜角度</param>
        /// <param name="x0">圆心坐标x</param>
        /// <param name="y0">圆心坐标y</param>
        /// <param name="x1">倾斜情况下帧图的坐标x</param>
        /// <param name="y1">倾斜情况下帧图的坐标y</param>
        /// <param name="Hx">复位到原位置需要移动的x值(返回值)</param>
        /// <param name="Hy">复位到原位置需要移动的y值(返回值)</param>
        /// <returns></returns>
        public bool Straightening(float Slope, float x0, float y0, float x1, float y1, ref float Hx, ref float Hy)
        {
            try
            {
                float xr = x1 - x0;//倾斜图到中心的距离差x
                float yr = y1 - y0;//倾斜图到中心的距离差y
                float R = (float)Math.Sqrt(xr * xr + yr * yr);//圆心到倾斜图的长度
                //double D = 2 * R * Math.Sin(ScanRotation / 2);//倾斜图与矫正图底边的长度
                float k = (float)(Math.Atan(yr / xr) / Math.PI * 180);//x1,y1的直角三角形圆心角度
                float k_S = k - Slope;//通过夹角差求x2,y2
                //int y2 = (int)Math.Round(Math.Sin(Math.PI / (180 / k_S)) * R);
                //int x2 = (int)Math.Round(Math.Cos(Math.PI / (180 / k_S)) * R);

                float y2 = (float)(Math.Sin(Math.PI / (180 / k_S)) * R);
                float x2 = (float)(Math.Cos(Math.PI / (180 / k_S)) * R);

                if (Slope > 0 || Slope < 0)
                {
                    Hx = x0 + x2;
                    Hy = y0 + y2;
                }
                else
                {
                    Hx = 0;
                    Hy = 0;
                }

                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        // 放大倍数差校正
        public bool MagComp(float oldMag, float newMag)
        {
            //开启电压校正时进行电压校正
            if (m_measureFile.MParam.MagComp)
            {
                int oldLevel = -1, newLevel = -1;
                float deltX = 0, deltY = 0;

                if (oldMag < m_measureFile.MParam.MagRange1)
                {
                    oldLevel = 1;
                }
                else if ((oldMag <= m_measureFile.MParam.MagRange2)
                    && (oldMag > m_measureFile.MParam.MagRange1))
                {
                    oldLevel = 2;
                }
                else if ((oldMag <= m_measureFile.MParam.MagRange3)
                    && (oldMag > m_measureFile.MParam.MagRange2))
                {
                    oldLevel = 3;
                }
                else if ((oldMag <= m_measureFile.MParam.MagRange4)
                    && (oldMag > m_measureFile.MParam.MagRange3))
                {
                    oldLevel = 4;
                }

                if (newMag < m_measureFile.MParam.MagRange1)
                {
                    newLevel = 1;
                }
                else if ((newMag <= m_measureFile.MParam.MagRange2)
                    && (newMag > m_measureFile.MParam.MagRange1))
                {
                    newLevel = 2;
                }
                else if ((newMag <= m_measureFile.MParam.MagRange3)
                    && (newMag > m_measureFile.MParam.MagRange2))
                {
                    newLevel = 3;
                }
                else if ((newMag <= m_measureFile.MParam.MagRange4)
                    && (newMag > m_measureFile.MParam.MagRange3))
                {
                    newLevel = 4;
                }

                if (oldLevel != newLevel)
                {
                    if (oldLevel == 1)
                    {
                        switch (newLevel)
                        {
                            case 1:
                                break;
                            case 2:
                                deltX = m_measureFile.MParam.MagCompX1;
                                deltY = m_measureFile.MParam.MagCompY1;
                                break;
                            case 3:
                                deltX = m_measureFile.MParam.MagCompX1 + m_measureFile.MParam.MagCompX2;
                                deltY = m_measureFile.MParam.MagCompY1 + m_measureFile.MParam.MagCompY2;
                                break;
                            case 4:
                                deltX = m_measureFile.MParam.MagCompX1 + m_measureFile.MParam.MagCompX2 + m_measureFile.MParam.MagCompX3;
                                deltY = m_measureFile.MParam.MagCompY1 + m_measureFile.MParam.MagCompY2 + m_measureFile.MParam.MagCompY3;
                                break;
                        }
                    }
                    else if (oldLevel == 2)
                    {
                        switch (newLevel)
                        {
                            case 1:
                                deltX = -m_measureFile.MParam.MagCompX1;
                                deltY = -m_measureFile.MParam.MagCompY1;
                                break;
                            case 2:
                                break;
                            case 3:
                                deltX = m_measureFile.MParam.MagCompX2;
                                deltY = m_measureFile.MParam.MagCompY2;
                                break;
                            case 4:
                                deltX = m_measureFile.MParam.MagCompX2 + m_measureFile.MParam.MagCompX3;
                                deltY = m_measureFile.MParam.MagCompY2 + m_measureFile.MParam.MagCompY3;
                                break;
                        }
                    }
                    else if (oldLevel == 3)
                    {
                        switch (newLevel)
                        {
                            case 1:
                                deltX = -m_measureFile.MParam.MagCompX1 - m_measureFile.MParam.MagCompX2;
                                deltY = -m_measureFile.MParam.MagCompY1 - m_measureFile.MParam.MagCompY2;
                                break;
                            case 2:
                                deltX = -m_measureFile.MParam.MagCompX2;
                                deltY = -m_measureFile.MParam.MagCompY2;
                                break;
                            case 3:
                                break;
                            case 4:
                                deltX = -m_measureFile.MParam.MagCompX2 - m_measureFile.MParam.MagCompX3;
                                deltY = -m_measureFile.MParam.MagCompY2 - m_measureFile.MParam.MagCompX3;
                                break;
                        }
                    }
                    else if (oldLevel == 4)
                    {
                        switch (newLevel)
                        {
                            case 1:
                                deltX = -m_measureFile.MParam.MagCompX1 - m_measureFile.MParam.MagCompX2 - m_measureFile.MParam.MagCompX3;
                                deltY = -m_measureFile.MParam.MagCompY1 - m_measureFile.MParam.MagCompY2 - m_measureFile.MParam.MagCompY3;
                                break;
                            case 2:
                                deltX = -m_measureFile.MParam.MagCompX2 - m_measureFile.MParam.MagCompX3;
                                deltY = -m_measureFile.MParam.MagCompY2 - m_measureFile.MParam.MagCompY3;
                                break;
                            case 3:
                                deltX = -m_measureFile.MParam.MagCompX3;
                                deltY = -m_measureFile.MParam.MagCompY3;
                                break;
                            case 4:
                                break;
                        }
                    }

                    //通过移动光束校正便宜量
                    //单位是m/pix
                    float pixSize = iSEM.GetPixelSize();
                    log.Info("像素尺寸=" + pixSize.ToString() + "m/pixel", true);

                    Thread.Sleep(500);

                    float xpCur = iSEM.GetStageAtX();
                    float ypCur = iSEM.GetStageAtY();

                    log.Info("当前位置（" + xpCur.ToString() + "," + ypCur.ToString() + "),单位m", true);

                    float xpNew = xpCur - deltX;
                    float ypNew = ypCur + deltY;

                    log.Info("目标位置（" + xpNew.ToString() + "," + ypNew.ToString() + "),单位m", true);

                    //计算最大偏移量
                    float beamXCur = iSEM.GetBeamShiftX();//单位是%

                    iSEM.SetBeamShiftX(100);
                    float beamXMax = iSEM.GetBeamOffsetX();//单位是m

                    iSEM.SetBeamShiftX(beamXCur);

                    //计算光束偏移值：
                    float beamX = iSEM.GetBeamOffsetX();
                    log.Info("当前X方向光束偏移量=" + beamX.ToString() + "m", true);

                    beamX = (-deltX + beamX);
                    log.Info("X方向光束偏移量应为=" + beamX.ToString() + "m", true);

                    if (beamX < beamXMax || beamX < -beamXMax)
                    {
                        log.Info("X方向移动光束", true);
                        float beamXShift = beamX * 100 / beamXMax;
                        if (!iSEM.SetBeamShiftX(beamXShift))
                        {
                            log.Info("X方向光束偏移量" + beamX.ToString() + "m失败", true);
                            return false;
                        }
                    }
                    else if (deltX > 0.000003 || deltX < -0.000003)//大于3um使用移动样品台实现
                    {
                        log.Info("X方向移动样品台", true);

                        if (!iSEM.SetStageGotoX(xpNew))
                        {
                            return false;
                        }

                        //判断是否移动完成
                        while (true)
                        {
                            Thread.Sleep(5000);
                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }
                    }

                    float beamY = iSEM.GetBeamOffsetY();
                    log.Info("当前Y方向光束偏移量=" + beamY.ToString() + "m", true);

                    beamY = (-deltY + beamY);
                    log.Info("Y方向光束偏移量应为=" + beamY.ToString() + "m", true);

                    //计算最大偏移量
                    float beamYCur = iSEM.GetBeamShiftY();//单位是%

                    iSEM.SetBeamShiftY(100);
                    float beamYMax = iSEM.GetBeamOffsetY();//单位是m

                    iSEM.SetBeamShiftY(beamYCur);

                    if (beamY < beamYMax || beamY < -beamYMax)
                    {
                        log.Info("Y方向移动光束", true);
                        float beamYShift = beamY * 100 / beamYMax;
                        if (!iSEM.SetBeamShiftY(beamY))
                        {
                            log.Info("Y方向光束偏移量" + beamY.ToString() + "m失败", true);
                            return false;
                        }
                    }
                    else if (deltY > 0.000003 || deltY < -0.000003)//大于3um使用移动样品台实现
                    {
                        log.Info("Y方向移动样品台", true);

                        if (!iSEM.SetStageGotoY(ypNew))
                        {
                            return false;
                        }

                        //判断是否移动完成
                        while (true)
                        {
                            Thread.Sleep(5000);
                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }
                        //arg.Message = "移动到新x" + xpNew.ToString() + "位置失败";
                        //arg.State = true;
                        //SendMsg("1-7");
                    }
                }
            }

            return true;
        }
        #endregion

        #region 测试程序
        //最后保存测量数据-测量文件、测量状态，m_cutHoles[i].STATE!=MeasureData.CutHole.State.Success.
        //中间停止更新状态为Unmeasured,过程中return false时，更新状态为failed,保存测量文件

        //if (DialogResult.Yes == MessageBox.Show("图像拍摄已完成？", "确认消息", MessageBoxButtons.YesNo))
        //{
        //    SendMsg("拍摄照片完成");
        //    //return true;
        //}
        //else
        //{
        //    SendMsg("拍摄照片失败");
        //    return false;
        //}

        //SendMsg("图像校正36度");
        ////3.设置SEM角度补偿cos36度
        //if (!TiltCorrection(36))
        //{
        //    return false;
        //}

        //Thread.Sleep(3000);

        //string fn;
        //用宏抓一般图

        //Thread.Sleep(5000);
        //fn = m_ProgramFolder + "\\Macro\\" + MacoScanPic;
        //SendMsg("用宏抓一般图" + fn);
        //iSEM.CMDMCFFilename(fn);
        ////延时1s？？
        //Thread.Sleep(5000);

        ////用宏抓好图
        //fn = m_ProgramFolder + "\\Macro\\" + MacoGoodPic;
        //SendMsg("用宏抓好图" + fn);
        //iSEM.CMDMCFFilename(fn);
        ////延时1s？？
        //Thread.Sleep(30000);

        //Thread.Sleep(10000);

        //WorkingFolder = m_measureFile.FilePath;
        //String fileName6 = WorkingFolder + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName6;
        //SendMsg("SEM拍照存储到" + fileName6);
        //if (!GetImage(ImageMode.SEM, fileName6))
        //{
        //    SendMsg("SEM拍照失败");
        //    return false;
        //}


        ////用宏抓标志图
        //fn = m_ProgramFolder + "\\Macro\\" + MacoExportTif;
        //SendMsg("用宏抓标志图" + fn);
        //iSEM.CMDMCFFilename(fn);
        ////延时1s？？
        //Thread.Sleep(30000);

        //Thread.Sleep(5000);
        //fn = m_ProgramFolder + "\\Macro\\" + MacoScanPic;
        //SendMsg("用宏抓一般图" + fn);
        //iSEM.CMDMCFFilename(fn);
        ////延时1s？？
        //Thread.Sleep(5000);


        //SendMsg("所有图结束");

        ////17.自动控制SEM拍截面照
        //{
        //    //1.控制SEM放大到指定参数大小范围，6000x
        //    if (!iSEM.SetMagnification(6000))
        //    {
        //        return false;
        //    }
        //    //2.控制SEM自动对焦、消像散、亮度、对比度
        //    if (!MeasParam.FocusMode)
        //    {
        //        //弹出手动对焦的窗口
        //    }
        //    else
        //    {
        //        //调用自动对焦模块
        //    }

        //    //3.设置SEM角度补偿cos36度
        //    if (!TiltCorrection(36))
        //    {
        //        return false;
        //    }

        //    //4.控制SEM拍照
        //    //5.保存照片4
        //    String fileName5 = WorkingFolder + ImageName5;
        //    if (!GetImage(ImageMode.SEM, fileName5))
        //    {
        //        return false;
        //    }
        //    //6.将照片传给客户，获取偏移坐标
        //    float x6 = 0, y6 = 0;
        //    float angle1 = 0;
        //    float mage = 10000;

        //    //7.根据坐标控制SEM移动到分析位置
        //    if (!iSEM.MoveStageXY(x6, y6))
        //    {
        //        return false;
        //    }
        //    //8.验证移动准确性：获取当前SEM中心位置坐标，与客户返回坐标对比，验证是否移动正确

        //    float x7 = iSEM.GetStageAtX();
        //    float y7 = iSEM.GetStageAtY();
        //    if (Math.Abs(x6 - x7) > fMin && Math.Abs(y6 - y7) > fMin)
        //    {
        //        return false;
        //    }

        //    //9.控制SEM平行校正，并记录校正前初始值
        //    float foldAnagle = iSEM.GetScanRotation();
        //    if (foldAnagle == float.NaN)
        //    {
        //        return false;
        //    }

        //    if (!iSEM.SetScanRotation(angle1))
        //    {
        //        return false;
        //    }

        //    //10.控制SEM放大到指定参数大小范围
        //    if (!iSEM.SetMagnification(mage))
        //    {
        //        return false;
        //    }

        //    //11.控制SEM自动对焦、消像散、亮度、对比度
        //    if (!MeasParam.FocusMode)
        //    {
        //        //弹出手动对焦的窗口
        //    }
        //    else
        //    {
        //        //调用自动对焦模块
        //    }


        //    //12.控制SEM对分析位置拍照
        //    String fileName6 = WorkingFolder + ImageName6;
        //    if (!GetImage(ImageMode.SEM, fileName6))
        //    {
        //        return false;
        //    }
        //    //13.保存照片
        //    //14.控制SEM取消电子束校正，回到初始值

        //    if (!iSEM.SetScanRotation(foldAnagle))
        //    {
        //        return false;
        //    }
        //}
        ////18.自动层高分析
        //{
        //    //1.获取SEM Pixel Size给客户传入参数
        //    if (iSEM.GetPixelSize() == float.NaN)
        //    {
        //        return false;
        //    }
        //    //2.将照片传给客户，客户进行层高分析（返回分析后的图像、相对坐标、分辨率、各层编号以及各层对应的层高数据），如果客户自行出分析报告则无需返回数据
        //}
        ////19.自动能谱分析
        //{
        //    //1. 确定能谱位置
        //    //2. 控制牛津打能谱
        //    //3. 能谱分析——面扫+线扫描
        //}
        #endregion

        #region 能谱所有参数
        //全局只有一个Extender
        static ExtenderInterface factoryExtender = ExtenderInterface.Instance;
        IExtenderControl iExtender;
        MeasureDB m_MeasDB = null;
        int m_nXrayId = 0;
        const String ImageNameEDS = @"EDSImage.tif"; //EDS能谱图片
        const String ImageNameEDS4 = @"SEMTrapCPEDS.tif";//传给客户，找到已经切割点
        const String ImageNameEDS5 = @"SEMDegreeTrapEDS.tif";//传给客户，水平校正
        const String ImageNameEDS6 = @"SEMMagEndEDS.tif";//传给客户，测量层高

        /// <summary>
        /// 做能谱分析
        /// </summary>
        /// <param name="a_PointNum">分析点ID，索引号</param>
        /// <param name="PointsName">分析点名称</param>
        /// <param name="num">分析点的位置ID</param>
        /// <returns>成功或失败</returns>
        public bool DoEDS(int a_PointNum, string PointsName, int num)
        {
            try
            {
                iExtender = factoryExtender.IExtender;
                //XrayID记录
                log.Info("程序进入EDS测量！", true);

                EDSParam param = m_measureFile.MParam.EDSP;
                double dDwellTime = param.DwellTime;
                int nImageType = param.ImageType;
                double dScanSizes = param.ScanSize;
                log.Info("dDwellTime=" + dDwellTime.ToString() + " nImageType=" + nImageType.ToString() + " dScanSizes=" + dScanSizes.ToString(), true);
                iExtender.SetImageAcquistionSetting(dDwellTime, nImageType, dScanSizes);

                string path = EDS_path;
                string edsfn = path + "\\" + num.ToString() + "_" + ImageNameEDS;
                log.Info("EDS_PATH=" + edsfn, true);
                iExtender.GrabImage(edsfn, 0, 0, 0, 0, 0);

                //送给客户，计算感兴趣的区域
                List<System.Drawing.Point> listPoints = new List<System.Drawing.Point>();
                List<System.Drawing.Point> listlines = new List<System.Drawing.Point>();
                List<List<Segment>> listFeature = new List<List<Segment>>();
                List<int> lines_height = new List<int>();
                System.Drawing.Point area_pt = new System.Drawing.Point();
                int width = 1;
                int height = 1;
                //点数据
                int state = 0;
                wr.EDS_Param_Points(edsfn, num, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out listPoints, out state);
                if (state == 0)
                {
                    log.Error("点采集失败", false);
                    return false;
                }

                //线数据
                log.Info("线扫描", true);
                state = 0;
                wr.EDS_Param_Lines(edsfn, num, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out listlines, out lines_height, out state);
                log.Info("线返回数据" + listlines[0].X.ToString() + "," + listlines[0].Y.ToString() + ",lines_height=" + lines_height.Count.ToString(), true);
                if (state == 1)
                {
                    //将线转换为segment数据
                    log.Info("将线转换为segment数据", true);
                    List<Segment> segments = new List<Segment>();
                    for (int i = 0; i < listlines.Count; i++)
                    {
                        for (int j = 0; j <= lines_height[i]; j++)
                        {
                            Segment segment = new Segment();
                            segment.X = listlines[0].X;
                            segment.Y = listlines[0].Y + j;
                            segment.Length = 1;
                            segments.Add(segment);
                        }
                        listFeature.Add(segments);
                    }
                    log.Info("将线转换为segment数据完成", true);
                }
                else
                {
                    log.Error("线采集失败", false);
                    return false;
                }

                //面数据
                state = 0;
                wr.EDS_Param_Areas(edsfn, num, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out area_pt, out width, out height, out state);
                log.Info("面返回数据" + area_pt.X.ToString() + "," + area_pt.Y.ToString() + ",height=" + height.ToString() + ",width=" + width.ToString(), true);
                if (state == 1)
                {
                    //将面转换为segment数据
                    log.Info("将面转换为segment数据", true);
                    List<Segment> segments = new List<Segment>();
                    for (int j = 0; j <= height; j++)
                    {
                        Segment segment = new Segment();
                        segment.X = area_pt.X;
                        segment.Y = area_pt.Y + j;
                        segment.Length = width;
                        segments.Add(segment);
                    }
                    listFeature.Add(segments);
                    log.Info("将面转换为segment数据完成", true);
                }
                else
                {
                    log.Error("面采集失败", false);
                    return false;
                }

                //存储数据
                //向分析点数据库更新
                log.Info("listPoints=" + listPoints.Count.ToString() + ",listFeature=" + listFeature.Count.ToString(), true);
                if (!m_MeasDB.InsetAPoint(a_PointNum, PointsName, EDS_path, listPoints.Count, listFeature.Count, num))
                {
                    log.Error("插入分析点失败", false);
                }
                log.Info("插入分析点成功", true);

                int AreasNo = 0;
                long[] XrayData = new long[2000];
                Dictionary<string, double> listElement = new Dictionary<string, double>();

                //点采集
                foreach (System.Drawing.Point pt in listPoints)
                {
                    XrayData = new long[2000];
                    listElement = new Dictionary<string, double>();
                    //log.Info("点采集开始", true);
                    iExtender.XrayPointCollectiong(param.PointTime, pt.X, pt.Y, out XrayData, out listElement);

                    //写入数据库
                    m_nXrayId++;
                    Boolean ret = m_MeasDB.InsertAPointXay(a_PointNum, m_nXrayId, pt.X, pt.Y, XrayData, listElement, num);
                    log.Info("点采集结束，写入数据库开始--" + m_nXrayId.ToString() + "," + ret.ToString(), true);
                    //log.Info("点采集写入数据库结束", true);
                    if (m_nXrayId % 5 == 0)
                    {
                        Thread.Sleep(5000);
                    }
                    else
                    {
                        Thread.Sleep(1000);
                    }

                }
                //面采集
                foreach (List<Segment> listSeg in listFeature)
                {
                    XrayData = new long[2000];
                    listElement = new Dictionary<string, double>();
                    log.Info("面采集开始", true);
                    log.Info("AreaTime=" + param.AreaTime.ToString(), true);
                    iExtender.XrayAreaCollectiong(param.AreaTime, listSeg, out XrayData, out listElement);
                    log.Info("面采集结束，写入数据库开始", true);
                    //写入数据库
                    m_nXrayId++;

                    AreasNo++;
                    m_MeasDB.InsertAAreaXay(a_PointNum, m_nXrayId, AreasNo, listSeg, XrayData, listElement, num);
                    log.Info("面采集写入数据库结束", true);
                }
            }
            catch (Exception e)
            {
                log.Error(e.Message, false);
            }
            return true;
        }

        /// <summary>
        /// 初始化数据库
        /// </summary>
        public void Init_MeasDB()
        {
            m_MeasDB = new MeasureDB(m_measureFile);
        }

        /// <summary>
        /// 161.自动调整SEM找到切割位置，这里不是简单的拉直旋转
        /// </summary>
        /// <returns></returns>
        public bool EDS_FindCross()
        {
            float x2 = 0, y2 = 0;
            int state = 0;

            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
            float m_TempBrightness = 50.0f;
            float m_TempContrast = 30.0f;
            if (m_measureFile.MParam.SampleName == "3")
            {
                m_TempBrightness = 48.0f;
                m_TempContrast = 29.0f;
            }
            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题    
            iSEM.SetAutoVideoOff();
            Thread.Sleep(200);
            iSEM.SetBrightness(m_TempBrightness);//50.0f
            Thread.Sleep(200);
            iSEM.SetContrast(m_TempContrast);//30.0f
            Thread.Sleep(200);
            
            //1.控制SEM放大到300倍
            float mag = m_measureFile.MParam.Photograph_Magnification / 3;
            if (mag < 200)
            {
                mag = 200;
            }
            if (!iSEM.SetMagnification(mag))
            {
                arg.Message = "放大" + mag.ToString("0.0") + "倍失败";
                arg.State = false;
                SendMsg("1-24");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            Thread.Sleep(200);
            float current = iSEM.GetMagnification();
            Thread.Sleep(200);
            while (Math.Abs(current - mag) > 2)
            {
                iSEM.SetMagnification(mag);
                Thread.Sleep(200);

                current = iSEM.GetMagnification();
                Thread.Sleep(200);
            }
            Thread.Sleep(2000);
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //3.控制SEM拍照
            //String fileName4 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + mag.ToString("0") + "_" + ImageNameEDS4;
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称
            String fileName4 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + mag.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageNameEDS4;
            log.Info("fileName4=============" + fileName4, true);
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
            arg.Picture_Information.Picture_FullPath = fileName4;
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(200);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(200);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(200);

            //拍照前改变速度,延时
            //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
            //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) + 100);

            if (!GetImage(fileName4))
            {
                //arg.State = false;
                //arg.Message = "SEM拍照找切割位置失败";
                //SendMsg("1-25");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            //arg.Picture_Information.Picture_FullPath = fileName4;
            //arg.State = true;
            //arg.Message = "SEM拍照成功";
            //SendMsg("1-25");
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //4.将照片传给客户，获取偏移坐标，以及偏移角度
            //5.根据坐标控制SEM移动到切孔位置，居中
            log.Info("测量线程：图像处理接口，准备移动样品台", true);
            log.Info("文件名=" + fileName4, true);
            wr.Img_Trapezoid_Top_Center_Position(fileName4, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out x2, out y2, out state);
            log.Info("梯形中心点返回数据=" + x2.ToString() + ", " + y2.ToString(), true);
            log.Info("准备移动样品台返回状态=" + state.ToString(), true);
            if (state == 1)
            {
                //1. 根据客户PT沉积坐标控制FIB调整到中心位置？？？？？？？
                if (!MoveToPixByMoveStage(x2, y2))
                {
                    //arg.State = false;
                    //arg.Message = "移动到新(" + x2.ToString() + "," + y2.ToString() + ")位置失败";
                    //SendMsg("1-26");
                    log.Error("测量线程报错：" + arg.Message, false);
                    return false;
                }
                //判断是否移动完成
                while (true)
                {
                    Thread.Sleep(4000);
                    if (iSEM.GetStageIs() == 0)
                    {
                        break;
                    }
                }
                //arg.State = true;
                //arg.Message = "移动到新(" + x2.ToString() + "," + y2.ToString() + ")位置成功";
                //SendMsg("1-26");

                //高倍到低倍不进行对焦

                //拍照前改变速度,延时
                //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
                //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) + 100);

                if (hand_intervene == 1)
                {
                    MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                }
            }
            else
            {
                arg.Message = "图像接口参数state返回值为零";
                arg.State = false;
                SendMsg("1-26");
                if (hand_intervene == 1)
                {
                    if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            return true;
        }

        /// <summary>
        /// 171.能谱第17步找点采集数据
        /// </summary>
        /// <returns></returns>
        public bool EDS_ShotSection()
        {
            int state = 0;

            #region 设置拍照的放大倍数
            log.Info("测量线程：设置拍照放大倍数" + m_measureFile.MParam.Photograph_Magnification.ToString(), true);
            if (!iSEM.SetMagnification(m_measureFile.MParam.Photograph_Magnification))
            {
                //arg.Message = "放大倍数调整失败";
                //arg.State = false;
                //SendMsg("1-27");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }

            float set = m_measureFile.MParam.Photograph_Magnification;
            float current = iSEM.GetMagnification();
            while (Math.Abs(current - set) > 1)
            {
                iSEM.SetMagnification(m_measureFile.MParam.Photograph_Magnification);
                Thread.Sleep(200);
                current = iSEM.GetMagnification();
            }

            //arg.Message = "放大" + m_measureFile.MParam.Photograph_Magnification.ToString() + "成功";
            //arg.State = true;
            //SendMsg("1-27");
            Thread.Sleep(3000 + (Int32)cycle_time);

            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }
            #endregion

            #region 拍摄矩形的切割孔，使用拍照的放大倍数
            //2.控制SEM自动对焦、亮度、对比度-接口
            iSEM.SetReduced(402, 128, 340, 256);
            Thread.Sleep(200);
            //add by sun 2020-12-15
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedFocus);//iSEM.CmdFocusRate(5);//
            //add by sun 2020-12-15 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));

            if (!iSEM.SetAutoVideoOff())
            {
                log.Error("测量线程报错：自动开启亮度对比度失败", false);
                return false;
            }
            Thread.Sleep(5000);

            if (ImageFocus1(false))
            {
                //arg.Message = "自动对焦完成";
                //arg.State = true;
                //SendMsg("1-28");
            }
            else
            {
                //arg.Message = "自动对焦失败";
                //arg.State = false;
                //SendMsg("1-28");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            iSEM.CloseReduced();
            Thread.Sleep(200);

            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(200 + Convert.ToInt32(cycle_time));
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            if (!iSEM.SetAutoVideoBrightnessAndContrast())
            {
                log.Error("测量线程报错：自动开启亮度对比度失败", false);
                return false;
            }
            Thread.Sleep(5000);

            //3、设置SEM补偿角度
            if (m_measureFile.MParam.Is_Photograph == false)
            {
                log.Info("测量线程：角度补偿" + m_measureFile.MParam.Correction_Angle.ToString() + "度", true);
                if (!TiltCorrection(m_measureFile.MParam.Correction_Angle))
                {
                    //arg.Message = "设置SEM进行角度补偿" + m_measureFile.MParam.Correction_Angle.ToString("0") + "度失败";
                    //arg.State = false;
                    //SendMsg("1-29");
                    log.Error("测量线程报错：" + arg.Message, false);
                    return false;
                }
                //arg.State = true;
                //arg.Message = "设置SEM进行角度补偿" + m_measureFile.MParam.Correction_Angle.ToString("0") + "度成功";
                //SendMsg("1-29");
                Thread.Sleep(200);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Error("停止键按下", false);
                    return false;
                }
            }

            //4、拍照，5、保存照片
            //String fileName5 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "_" + ImageNameEDS5;
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称
            String fileName5 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageNameEDS5;
            log.Error("fileName5==============="+ fileName5, false);
            //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
            arg.Picture_Information.Picture_FullPath = fileName5;
            arg.Picture_Information.Work_Status = "SEM";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(200);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(200);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(200);
            //拍照前改变速度,延时
            //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
            //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) * 2);
            if (!GetImage(fileName5))
            {
                //arg.Message = "SEM拍照失败";
                //arg.State = false;
                //SendMsg("1-30");
                log.Error("测量线程报错：" + arg.Message, false);
                return false;
            }
            //arg.State = true;
            //arg.Message = "SEM拍照成功";
            //SendMsg("1-30");
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }
            #endregion

            if (m_measureFile.MParam.Is_Photograph == false)
            {
                #region 对当前矩形进行旋转校正
                //8,计算切割面区域偏移角度及方向
                float degree = 0;
                int direction = 0;

                wr.Img_Center_Position_OffsetAngle_Direction(fileName5, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out degree, out direction, out state);
                log.Info("测量线程：拍照角度移动,输入图像" + ImageNameEDS5 + "输出角度为" + degree.ToString() + "输出方向为" + direction.ToString() + "返回值为" + state.ToString(), true);
                log.Info("样品" + m_nWorkHoleNo.ToString() + "计算切割面区域的角度=" + degree.ToString(), true);
                //接口返回像素，*pixelsize,得到坐标点。判断移动方式
                if (state == 1)
                {
                    //梯形角度
                    iSEM.SetScanRotationOn();
                    Thread.Sleep(200);
                    //20201128陈工要求，谭博返回角度*0.7
                    iSEM.SetScanRotation(Convert.ToSingle(degree * m_measureFile.MParam.ScanRotCor));
                    Thread.Sleep(200);

                    //arg.State = true;
                    //arg.Message = "图像接口返回角度为：" + degree.ToString();
                    //SendMsg("1-31");

                    if (hand_intervene == 1)
                    {
                        MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                    }
                }
                else
                {
                    //arg.Message = "图像接口参数State返回值为零";
                    //arg.State = false;
                    //SendMsg("1-31");
                    if (hand_intervene == 1)
                    {
                        if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        //return false;
                    }

                    log.Error("测量线程报错：" + arg.Message, false);
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

                Thread.Sleep(200);

                //12拍照
                //String fileName6 = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "_" + ImageNameEDS6;
                //add by zjx 2020-12-21 根据客户的需求修改图片的名称
                String fileName6 = data_path + "\\" + m_measureFile.MParam.Firm + "-" + m_measureFile.MParam.Photograph_Magnification.ToString("0") + "-" + m_cutHoles[m_nWorkHoleNo].HoleName + "-" + ImageNameEDS6;
                //add by zjx 2020-12-21 根据客户的需求修改图片的名称 end 
                log.Info("fileName6===================" + fileName6, true);
                arg.Picture_Information.Picture_FullPath = fileName6;
                arg.Picture_Information.Work_Status = "SEM";
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(200);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(200);
                arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
                Thread.Sleep(200);
                //拍照前改变速度,延时
                //add by sun 2020-12-15 增加不同样品扫描速度参数,每大类样品3种扫描速度
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedHigh);//iSEM.CmdSaveRate();
                //add by sun 2020 - 12 - 15 增加不同样品扫描速度参数,每大类样品3种扫描速度 end
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
                if (!GetImage(fileName6))
                {
                    //arg.Message = "SEM拍照失败";
                    //arg.State = false;
                    //SendMsg("1-33");
                    log.Error("测量线程报错：" + arg.Message, false);
                    return false;
                }

                //arg.State = true;
                //arg.Message = "SEM拍照成功";
                //SendMsg("1-33");
                iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedNormal);//CmdFocusRate(4);
                Thread.Sleep(200);
                cycle_time = iSEM.GetCycleTime();
                Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }
                #endregion

                #region 获取两个位置上及放大倍数
                //计算两个测量区域坐标
                List<System.Drawing.Point> ct = new List<System.Drawing.Point>();
                List<float> mag = new List<float>();
                System.Drawing.Point ct0;
                float magMax = 0;
                //log.Info("测量线程：图像处理接口，计算两个放大区域坐标，输入图像" + fileName6.ToString() + "控制失败", true);
                wr.Img_Measure_Region_Position(fileName6, Convert.ToInt32(m_measureFile.MParam.SampleName), m_measureFile.MParam.Firm, out ct, out mag, out ct0, out state);

                log.Info("测量线程：图像处理接口返回值为" + state.ToString() +
                    "，计算两个放大区域坐标，输入图像" + fileName6.ToString() +
                    "输入样品" + Convert.ToInt32(m_measureFile.MParam.SampleName) +
                    "输入产品" + m_measureFile.MParam.Firm.ToString()
                    + "输出中心点1(x,y)为(" + ct[0].X.ToString() + "," + ct[0].Y.ToString() + ")"
                    + "输出放大倍数1" + mag[0]
                    + "输出中心点2(x,y)为(" + ct[1].X.ToString() + "," + ct[1].Y.ToString() + ")"
                    + "输出放大倍数2" + mag[0]
                    + "输出中心点3(x,y)为(" + ct0.X.ToString() + "," + ct0.Y.ToString() + ")", true);
                #endregion
                if (state == 1 && ct.Count != 0 && mag.Count != 0)
                {
                    //arg.State = true;
                    //arg.Message = "获取位置及放大倍数成功";
                    //SendMsg("1-34");

                    #region 记录初始设置的BeamShift的百分比和样品台XY位置
                    float xs = iSEM.GetBeamShiftX();
                    Thread.Sleep(200);
                    float ys = iSEM.GetBeamShiftY();
                    Thread.Sleep(200);
                    float xpCur = iSEM.GetStageAtX();
                    Thread.Sleep(200);
                    float ypCur = iSEM.GetStageAtY();
                    Thread.Sleep(200);
                    log.Info("测量线程：原来的光束偏移量x = " + xs.ToString()
                        + "y=" + ys.ToString() + ","
                        + "原来样品台的位置x= " + xpCur.ToString()
                        + "y=" + ypCur.ToString(), true);
                    #endregion

                    #region 移动到梯形左上角
                    //找到放大倍数最大值
                    magMax = mag[0];
                    for (int m = 1; m < mag.Count; m++)
                    {
                        if (mag[m] > magMax)
                        {
                            magMax = mag[m];
                        }
                    }

                    //20201127将视野移动到梯形左上角位置
                    MoveToPix(ct0.X, ct0.Y);

                    log.Info("测量线程：移动到对焦点（ " + ct0.X.ToString()
                        + "," + ct0.Y.ToString() + ")", true);

                    //关闭自动亮度对比度
                    iSEM.SetAutoVideoOff();
                    Thread.Sleep(2000);

                    iSEM.SetReduced(402, 128, 340, 256);
                    Thread.Sleep(200);
                    //add by sun 2020-12-15
                    iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedFocus);//CmdFocusRate(5);
                    //add by sun 2020-12-15 end
                    Thread.Sleep(200);
                    cycle_time = iSEM.GetCycleTime();
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    //放大到10000倍
                    iSEM.SetMagnification(magMax / 2);
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    set = magMax / 2;
                    current = iSEM.GetMagnification();
                    while (Math.Abs(current - set) > 1)
                    {
                        iSEM.SetMagnification(set);
                        Thread.Sleep(200);
                        current = iSEM.GetMagnification();
                    }



                    //自动对焦
                    if (!ImageFocus1(true))
                    {
                        return false;
                    }

                    //放大到10000倍
                    iSEM.SetMagnification(magMax);
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    set = magMax;
                    current = iSEM.GetMagnification();
                    while (Math.Abs(current - set) > 1)
                    {
                        iSEM.SetMagnification(set);
                        Thread.Sleep(200);
                        current = iSEM.GetMagnification();
                    }

                    //自动对焦
                    if (!ImageFocus1(true))
                    {
                        return false;
                    }


                    iSEM.CloseReduced();
                    Thread.Sleep(200);
                    cycle_time = iSEM.GetCycleTime();
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));
                    #endregion

                    #region 恢复到拍照的状态

                    iSEM.SetStageGotoX(xpCur);
                    while (true)
                    {
                        Thread.Sleep(4000);

                        if (iSEM.GetStageIs() == 0)
                        {
                            break;
                        }
                    }
                    iSEM.SetStageGotoY(ypCur);
                    while (true)
                    {
                        Thread.Sleep(4000);

                        if (iSEM.GetStageIs() == 0)
                        {
                            break;
                        }
                    }

                    iSEM.CloseReduced();
                    Thread.Sleep(200);
                    cycle_time = iSEM.GetCycleTime();
                    Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                    //增亮图像
                    iSEM.SetAutoVideoOff();
                    Thread.Sleep(200);

                    float currentBright = iSEM.GetBrightness();
                    Thread.Sleep(200);

                    float currentContrast = iSEM.GetContrast();
                    Thread.Sleep(200);

                    iSEM.SetBrightness(currentBright + 2);
                    Thread.Sleep(200);

                    iSEM.SetContrast(currentContrast + 2);//modify by sun 2020-12-16 黄工觉得太亮
                    Thread.Sleep(200);

                    #endregion

                    #region 循环拍照
                    for (int n = 0; n < ct.Count; n++)
                    {
                        #region 恢复到拍照的状态

                        iSEM.SetStageGotoX(xpCur);
                        while (true)
                        {
                            Thread.Sleep(4000);

                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }
                        iSEM.SetStageGotoY(ypCur);
                        while (true)
                        {
                            Thread.Sleep(4000);

                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }

                        //恢复原来的放大倍数
                        if (!iSEM.SetMagnification(m_measureFile.MParam.Photograph_Magnification))
                        {
                            log.Error("测量线程报错：第一个区域放大倍数" + mag[n].ToString() + "控制失败", false);
                            return false;
                        }
                        Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                        set = m_measureFile.MParam.Photograph_Magnification;
                        current = iSEM.GetMagnification();
                        while (Math.Abs(current - set) > 1)
                        {
                            iSEM.SetMagnification(set);
                            Thread.Sleep(200);
                            current = iSEM.GetMagnification();
                        }


                        //恢复BeamShift的百分比值
                        iSEM.SetBeamShiftX(xs);
                        Thread.Sleep(200);
                        iSEM.SetBeamShiftY(ys);
                        Thread.Sleep(200);

                        #endregion

                        #region 移动到指定点位置
                        if (!MoveToPix(ct[n].X, ct[n].Y))
                        {
                            arg.State = false;
                            arg.Message = "移动到第一个点位置失败";
                            SendMsg("1-" + (35 + n).ToString());
                            //移动到第一个点失败
                            log.Error("测量线程报错：移动到点(" + ct[n].X.ToString() + "," + ct[n].Y.ToString() + ")失败", false);
                        }

                        log.Info("测量线程：移动到第1个点（ " + ct[n].X.ToString()
                            + "," + ct[n].Y.ToString() + ")", true);
                        #endregion

                        #region 如果是第一个点，则1W倍对焦
                        if (n == 0)
                        {
                            
                        }
                        #endregion

                        #region 拍照
                        if (!iSEM.SetMagnification(mag[n]))
                        {
                            arg.State = false;
                            arg.Message = "移动到第一个点位置拍照失败";
                            SendMsg("1-35");
                            log.Error("测量线程报错：第一个区域放大倍数" + mag[n].ToString() + "控制失败", false);
                            return false;
                        }
                        Thread.Sleep(100 + Convert.ToInt32(cycle_time));

                        set = mag[n];
                        current = iSEM.GetMagnification();
                        while (Math.Abs(current - set) > 1)
                        {
                            iSEM.SetMagnification(set);
                            Thread.Sleep(200);
                            current = iSEM.GetMagnification();
                        }

                        DoEDS(m_nWorkHoleNo + 1, cutHoles[m_nWorkHoleNo].HoleName, n + 1);

                        #endregion
                    }

                    #endregion

                    if (hand_intervene == 1)
                    {
                        MessageBox.Show("Web返回数据移动是否正确？\n如果错误请手动移动到指定位置后按确认", "确认消息", MessageBoxButtons.OK);
                    }
                }
                else
                {
                    if (hand_intervene == 1)
                    {
                        if (DialogResult.Yes != MessageBox.Show("网络参数State返回为0。\n是否继续操作？。", "确认消息", MessageBoxButtons.YesNo))
                        {
                            // return false;
                        }
                    }
                    else
                    {
                        //return false;
                    }

                    //arg.State = false;
                    //arg.Message = "获取位置及放大倍数失败";
                    //SendMsg("1-34");

                    log.Error("测量线程报错：" + arg.Message, false);
                }
                //判断是否停止进程
                if (key_stop)
                {
                    log.Info("停止键按下", true);
                    return false;
                }

            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 19.能谱分析
        /// </summary>
        /// <returns></returns>
        public bool EDSAnalysis()
        {
            //1.先降Z轴  37.241左右使工作距离从5mm 变为 10mm，这样方便能谱工作，麻烦是需要从新对焦。由于移动样品台会有误差，容易造成图像偏移，最好从新定位
            if (m_measureFile.MParam.EDSZ < Z_Min || m_measureFile.MParam.EDSZ > Z_Max)
            {
                log.Info("Z轴位置设置超出范围.", true);
                return false;
            }
            log.Info("将Z轴位置指定到：" + m_measureFile.MParam.EDSZ.ToString(), true);
            if (!iSEM.SetStageGotoZ(m_measureFile.MParam.EDSZ))
            {
                log.Error("测量线程报错：样品台Z回到安全位置失败", false);
                return false;
            }
            

            while (true)
            {
                Thread.Sleep(4000);
                if (iSEM.GetStageIs() == 0)
                {
                    break;
                }
            }
            

            //判断是否停止进程
            if (key_stop)
            {
                log.Info("停止键按下", true);
                return false;
            }

            //2.角度改为54度
            iSEM.SetScanRotationOff();
            Thread.Sleep(200);

            //3.设置电压和电流
            iSEM.SetSEMVoltage(m_measureFile.MParam.EDSV);
            Thread.Sleep(2000);
            iSEM.SetSEMIPROBE(m_measureFile.MParam.EDSA);
            Thread.Sleep(500);

            //4.自动亮度对比度   del by sun 2020-12-17
            //iSEM.SetAutoBright(100);
            //Thread.Sleep(200);
            //iSEM.SetAutoContrast(100);
            //Thread.Sleep(200);
            //if (!iSEM.SetAutoVideoBrightnessAndContrast())
            //{
            //    log.Info("测量线程报错：开始设置自动亮度、对比度失败。", false);
            //    return false;
            //}
            //Thread.Sleep(5000);
            //del by sun 2020-12-17

            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题
            //关闭自动亮度对比度
            iSEM.SetAutoVideoOff();
            Thread.Sleep(2000);            
            float m_TempBrightness = 50f;
            float m_TempContrast = 29f;
            if (m_measureFile.MParam.SampleName == "3")
            {
                m_TempBrightness = 50f;
                m_TempContrast = 29f;                
            }
            iSEM.SetBrightness(m_TempBrightness); //50.0f
            Thread.Sleep(200);
            iSEM.SetContrast(m_TempContrast); //30.0f
            Thread.Sleep(5000);
            //add by sun 2020-12-17 解决3大类样品FIB下亮度过白导致无法识别问题 end


            //5.自动对焦
            iSEM.SetReduced(256, 192, 512, 512);
            Thread.Sleep(200);
            //add by sun 2020-12-15
            iSEM.CmdFocusScanSpeed(m_measureFile.MParam.ScanSpeedFocus);//CmdFocusRate(5);
            //add by sun 2020-12-15 end
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));

            if (!ImageFocus1(false))
            {
                return false;
            }

            iSEM.CloseReduced();
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));

            //6.调用161步过程
            if (!EDS_FindCross())
            {
                return false;
            }

            //7.调用171步过程
            if (!EDS_ShotSection())
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 20.光束等复位
        /// </summary>
        public void BeamShiftReset()
        {
            iSEM.SetTiltAngleOff();
            Thread.Sleep(200);
            iSEM.SetScanRotationOff();
            Thread.Sleep(200);
            iSEM.SetBeamShiftX(0);
            Thread.Sleep(200);
            iSEM.SetBeamShiftY(0);
            Thread.Sleep(200);
        }


        //add by sun 2020-12-17 不同样品电压、电流不一致，应设置灵活。123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA
        #region 设置电压电流
        public bool SetVoltageAndIPROBE()
        {            
            log.Info("测量线程：设置电压电流 123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA  目前是第 " + m_measureFile.MParam.SampleName + " 类！", true);
            //这块应该做成参数！！！ 暂时写死。类型3 则为 5000V 500pA
            bool mRet_VoltageFlag = false;
            bool mRet_ElecFlag = false;
            if (m_measureFile.MParam.SampleName != "3")
            {
                mRet_VoltageFlag = iSEM.SetSEMVoltage(2000);
                Thread.Sleep(500);
                mRet_ElecFlag = iSEM.SetSEMIPROBE(0.2F / 1000000000);
                Thread.Sleep(500);
            }
            else
            {
                mRet_VoltageFlag = iSEM.SetSEMVoltage(5000);
                Thread.Sleep(500);
                mRet_ElecFlag = iSEM.SetSEMIPROBE(0.5F / 1000000000);
                Thread.Sleep(500);
            }
            if (!mRet_VoltageFlag) return false;
            if (!mRet_ElecFlag) return false;
            log.Info("测量线程：设置电压电流完成！" , true);
            return true;
        }
        #endregion
        //add by sun 2020-12-17 不同样品电压、电流不一致，应设置灵活。123456类电压2000V电流200pA，7类5000V 500pA，能谱 7000V 500pA end

        //add by sun 2020-12-17 根据客户要求，3大类样品需要在5000倍下在拍摄一张图片，不需要分析
        #region 拍照
        public bool GetImageFromSEM(float m_Mag) { 
        
            if (!iSEM.SetMagnification(m_Mag))
            {
                log.Error("测量线程报错：第一个区域放大倍数" + m_Mag.ToString() + "失败", false);
                return false;
            }
            log.Info("========测量线程：移动到第一个点位置拍照完成(一半倍数)！", true);
            Thread.Sleep(100 + Convert.ToInt32(cycle_time));

            String m_FileName = data_path + "\\" + m_cutHoles[m_nWorkHoleNo].HoleName + "_" + m_Mag.ToString() + "_0_" + ImageNameTwo_1;
            //arg.Picture_Information.Picture_FullPath = m_FileName;
            //arg.Picture_Information.Work_Status = "SEM";
            //arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            //Thread.Sleep(200);
            //arg.Picture_Information.Magnification = iSEM.GetMagnification();
            //Thread.Sleep(200);
            //arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            //Thread.Sleep(200);
            //拍照前改变速度,延时
            iSEM.CmdLineScan();
            Thread.Sleep(200);
            cycle_time = iSEM.GetCycleTime();
            Thread.Sleep(Convert.ToInt32(cycle_time) + 100);
            if (!GetImage(m_FileName))
            {
                log.Error("测量线程报错：========" + arg.Message, false);
                return false;
            }
            log.Info("========测量线程：移动到第一个点位置完成！", true);
            return true;
        }
        #endregion
        //add by sun 2020-12-17 根据客户要求，3大类样品需要在5000倍下在拍摄一张图片，不需要分析 end
        //add by zjx 2020-12-21 在测量图上显示放大倍数和像素大小等信息
        public void SaveMeasDataPic(String picFullPath,float Mag,float pixelsize)
        {
            try
            {
                using (System.Drawing.Image img = Image.FromFile(picFullPath))
                {
                    Bitmap bmp = new Bitmap(img.Width, img.Height);
                    using (Graphics g = Graphics.FromImage(bmp))
                    {
                        g.DrawImage(img, 0, 0, img.Width, img.Height);
                        String str = "Mag:" + Mag.ToString("0") + "X\tPixelSize:" + (pixelsize * 1000000).ToString("0.00") + "um";
                        Font font =new Font("宋体", 16, FontStyle.Bold);
                        SolidBrush sbrush = new SolidBrush(Color.LimeGreen);
                        g.DrawString(str, font, sbrush, new PointF(40, img.Height - 30));
                    }
                    String path1 = Path.GetDirectoryName(picFullPath) + Path.GetFileNameWithoutExtension(picFullPath) + "_Data." + Path.GetExtension(picFullPath);
                    log.Info("Path.GetDirectoryName(picFullPath)==" + Path.GetDirectoryName(picFullPath) + "Path.GetFileNameWithoutExtension(picFullPath)==" + Path.GetFileNameWithoutExtension(picFullPath) + "Path.GetExtension(picFullPath)==" + Path.GetExtension(picFullPath), true);
                    log.Info("在测量图上显示放大倍数和像素大小信息==============="+ path1, true);
                    bmp.Save(path1);
                }
            }
            catch
            {
                log.Error("在测量图上显示放大倍数和像素大小信息失败", false);
            }
        }
        //add by zjx 2020-12-21 在测量图上显示放大倍数和像素大小等信息 end
        #endregion
    }
}