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 SmartSEMControl;
using MeasureData;
using FileManager;
using WebManager;

using OpenCvSharp;

namespace MeasureThread
{
    //图片模式
    public enum ImageMode
    {
        FIB,
        SEM
    }

    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;
        }
    }

    public class Measure
    {
        /// <summary>
        /// 图像拉直算法
        /// </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
            {
                double xr = x1 - x0;//倾斜图到中心的距离差x
                double yr = y1 - y0;//倾斜图到中心的距离差y
                double R = Math.Sqrt(xr * xr + yr * yr);//圆心到倾斜图的长度
                //double D = 2 * R * Math.Sin(ScanRotation / 2);//倾斜图与矫正图底边的长度
                double k = Math.Atan(y1 / x1) / Math.PI * 180;//x1,y1的直角三角形圆心角度
                double 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);

                if (Slope > 0 || Slope < 0)
                {
                    Hx = x1 - x2;
                    Hy = y1 - y2;
                }
                else
                {
                    Hx = 0;
                    Hy = 0;
                }

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

        //Web接口类
        public WebResult wr = null;

        //样品台保护值
        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 ImageName1 = @"ImageSEMH.tif"; //传给客户，作水平校正
        const String ImageName2 = @"ImageFIB600X1.tif";//传给客户，找到切割点
        const String ImageName31 = @"ImageFIBBefore.tif";
        const String ImageName32 = @"ImageFIBAfter.tif";
        const String ImageName4 = @"ImageSEM300X.tif";//传给客户，找到已经切割点
        const String ImageName5 = @"ImageSEM6000X.tif";//传给客户，水平校正
        const String ImageName6 = @"ImageSEMMag.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; //单位是米

        public Boolean key_stop = false;

        String focus_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; }
        }

        //测量参数
        private MeasureParam m_MsParam;
        public MeasureParam MeasParam
        {
            get { return this.m_MsParam; }
            set { this.m_MsParam = value; }
        }

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

        //初始化测量业务, 读测量文件，判断是否有可测试的切孔
        public bool InitMeas(MeasureFile a_measureFile)
        {
            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;

            this.m_MsParam = m_measureFile.MParam;

            return true;
        }

        public void SendMsg(string step_code)
        {
            arg.Step_Code = step_code;
            arg.Time = DateTime.Now;
            SendThreadStatus(this, arg);
        }

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

            if (SendThreadStatus != null)
            {
                //SendMsg("开始测量。");
            }

            LogManager.AddHardwareLog("开始测量",true);

            //检查硬件连接是否正常
            if (!ConnectHardware())
            {
                //SendMsg("连接硬件失败。");
                this.TStatus.ComputeTime(THREAD_TIME_TYPE.STOPPED);
                return;
            }

            //SendMsg("硬件连接成功。");

            //设置工作文件夹

            if (!SetWorkingFolderStr())
            {
                //SendMsg("设置工作文件夹失败");
                this.TStatus.ComputeTime(THREAD_TIME_TYPE.STOPPED);
                return;
            }

            //SendMsg("创建工作文件路径为" + WorkingFolder);

            float[] firstPosition;
            //将停止键复位
            key_stop = false;

            for (int i = 0; i < m_cutHoles.Count; i++)
            {
                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_MsParam.AutoFocus.Path = focus_path;
                if (!Directory.Exists(focus_path))
                {
                    Directory.CreateDirectory(focus_path);
                }

                //判断孔状态
                if(m_cutHoles[i].STATE != State.Ready)
                {
                    continue;
                }

                //开始循环工作
                if (i == 0)
                {
                    m_cutHoles[i].START = DateTime.Now;
                    //SendMsg("第一个切孔开始测量");
                    //切孔操作-开始
                    m_cutHoles[i].STATE = State.InProcess;
                    //SendCutHoleMsg(((int)ThreadState.InProcess).ToString(), m_cutHoles[i].HoleName);
                    SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    firstPosition = iSEM.GetStagePosition();
                    //第一个孔的测试
                    
                    //成功
                    if(FirstHole())
                    {
                        //保存文件，将测量状态更改
                        m_cutHoles[i].STATE = State.Success;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                    }
                    //失败
                    else
                    {
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                    }
                    //切孔操作-完成
                    //SendCutHoleMsg(((int)ThreadState.Success).ToString(), m_cutHoles[i].HoleName);
                    SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                }
                else
                {
                    //其他孔测量之前的初始化
                    if (!OtherHole_Init())
                    {
                        arg.Message = "当前测量点位置初始失败！";
                        SendMsg("0-1");
                        continue;
                    }

                    //其他孔的测量
                    m_cutHoles[i].START = DateTime.Now;
                    //非第一个孔的测试
                    //SendMsg("第" + i.ToString() + "个切孔开始测量");
                    //切孔操作-开始
                    //SendCutHoleMsg(((int)ThreadState.InProcess).ToString(), m_cutHoles[i].HoleName);
                    m_cutHoles[i].STATE = State.InProcess;
                    SendCutHoleMsg(((int)m_cutHoles[i].STATE).ToString(), m_cutHoles[i].HoleName);
                    //其他孔的测试
                    
                    //成功
                    if (OtherHole())
                    {
                        //保存文件，将测量状态更改
                        m_cutHoles[i].STATE = State.Success;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                    }
                    //失败
                    else
                    {
                        m_cutHoles[i].STATE = State.Failed;
                        m_cutHoles[i].END = DateTime.Now;
                        m_measureFile.Save();
                    }

                    //切孔操作-完成
                    //SendCutHoleMsg(((int)ThreadState.Success).ToString(), m_cutHoles[i].HoleName);
                    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();
                    arg.Message = "用户停止测量";
                    SendMsg("0-0");
                    break;
                }
            }
        }

        //检查硬件连接是否正常
        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文件
            string fn = m_ProgramFolder + "\\Macro\\" + ElyDeposition;
            //SendMsg("执行PT沉积Ely文件:" + fn);
            if (!ExcuteEly(fn))
            {
                return false;
            }

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

        //FIB切割
        public bool FIBWork()
        {
            //执行PT沉积的ELY文件
            string fn = m_ProgramFolder + "\\Macro\\" + ElyCrossSection;
            //SendMsg("执行FIB切割Ely文件:" + fn);
            if (!ExcuteEly(fn))
            {
                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;
        }

        //执行自动对焦
        public bool ImageFocus(String step_code)
        {
            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;
                AutoFocus(m_MsParam.AutoFocus, out wd, step_code);

                //LogManager.AddHardwareLog("算法输出"+ wd.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_MsParam.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>
        ///13. 自动 定位功能,沉积
        /// </summary>
        /// <returns></returns>
        public bool GetPoistion(Boolean isFirst)
        {
            float x0 = 0, y0 = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
            int state = 0;
            //切换到SEM模式
            if (!iSEM.CmdFIBModeSEM())
            {
                arg.Message = "SEM模式切换失败";
                arg.State = false;
                SendMsg("1-1");
                return false;
            }


            //1.控制SEM放大600X
            arg.Picture_Information.Work_Status = "SEM";
            if (!iSEM.SetSEMVoltage(m_MsParam.Location_Voltage))
            {
                arg.Message = "电压设置" + m_MsParam.Location_Voltage.ToString("0.0") + "失败";
                arg.State = false;
                SendMsg("1-1");
                return false;
            }
            if (!iSEM.SetMagnification(m_measureFile.MParam.Location_Magnification))
            {
                arg.Message = "放大" + m_measureFile.MParam.Location_Magnification.ToString("0.0") + "倍失败";
                arg.State = false;
                SendMsg("1-1");
                return false;
            }
            arg.State = true;
            arg.Message = "放大" + m_measureFile.MParam.Location_Magnification.ToString("0.0") + "倍成功";
            SendMsg("1-1");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //2.控制SEM自动对焦、亮度、对比度
            if(ImageFocus("1-2"))
            {
                arg.Message = "自动对焦完成";
                arg.State = true;
                SendMsg("1-2");
            }
            else
            {
                arg.Message = "自动对焦失败";
                arg.State = false;
                SendMsg("1-2");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
            
            //3.第一次不需要进行角度补偿，其他需要设置SEM进行角度补偿54度
            if (!isFirst)
            {
                if (!TiltCorrection(54))
                {
                    arg.Message = "设置SEM进行角度补偿54度失败";
                    arg.State = false;
                    SendMsg("1-3");
                    return false;
                }
                Thread.Sleep(5000);
                arg.State = true;
                arg.Message = "设置SEM进行角度补偿54度成功";
                SendMsg("1-3");
                
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
            }
            else
            {
                Thread.Sleep(2000);
                arg.State = true;
                arg.Message = "设置SEM进行角度补偿54度成功";
                SendMsg("1-3");
            }

            //4.控制SEM拍照,5保存照片=====需要更改路径
            String fileName1 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName1;
            arg.Picture_Information.Picture_FullPath = fileName1;
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(1000);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(1000);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(1000);
            if (!GetImage(ImageMode.SEM, fileName1))
            {
                arg.Message = "SEM拍照失败";
                arg.State = false;
                SendMsg("1-4");
                return false;
            }
            arg.State = true;
            arg.Message = "SEM拍照成功";
            SendMsg("1-4");
            Thread.Sleep(3000);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //判断是否为仅拍照，不是则执行FIB操作
            if (!m_MsParam.Is_Photograph)
            {
                //6.设置FIB拍照参数——扫描时间、束流等
                //7.控制FIB自动亮度、对比度
                if (!iSEM.CmdFIBModeFIB())
                {
                    arg.Message = "FIB模式切换失败";
                    arg.State = false;
                    SendMsg("1-5");
                    return false;
                }
                arg.State = true;
                arg.Picture_Information.Work_Status = "FIB";
                arg.Message = "FIB模式切换成功";
                SendMsg("1-5");
                Thread.Sleep(10000);
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }

                //8.控制FIB拍照
                //9.保存照片======更改路径
                String fileName2 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName2;
                arg.Picture_Information.Picture_FullPath = fileName2;
                arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
                Thread.Sleep(1000);
                arg.Picture_Information.Magnification = iSEM.GetMagnification();
                Thread.Sleep(1000);
                arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
                Thread.Sleep(1000);
                if (!GetImage(ImageMode.FIB, fileName2))
                {
                    arg.Message = "FIB拍照失败";
                    arg.State = false;
                    SendMsg("1-6");
                    return false;
                }
                arg.State = true;
                arg.Message = "FIB拍照成功";
                SendMsg("1-6");
                Thread.Sleep(3000);
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }

                //10.将照片传给客户，返回梯形位置坐标，及样品类型参数（是否需要PT沉积，PT坐标位置，PT宽度、PT高度、梯形上、下边及深度、扫描时间、束流、样品放大倍数1、样品放大倍数2等切割参数）
                if (DialogResult.Yes == MessageBox.Show("是否手动移动样品台到指定位置？\n如果点击取消则会调用Web接口。", "确认消息", MessageBoxButtons.YesNo))
                {
                    arg.Message = "样品台移动到指定位置";
                    arg.State = true;
                    SendMsg("1-7");
                }
                else
                {
                    wr.Img_Cut_Position(fileName2, m_MsParam.SampleName, m_MsParam.Firm, out x1, out y1, out x2, out y2, out state);
                    if (state == 1)
                    {
                        //1. 根据客户PT沉积坐标控制FIB调整到中心位置？？？？？？？
                        if (!iSEM.MoveStageXY(x1, y1))
                        {
                            arg.Message = "移动到新(" + x1.ToString() + "," + y1.ToString() + ")位置失败";
                            arg.State = false;
                            SendMsg("1-7");
                            return false;
                        }
                        //判断是否移动完成
                        while (true)
                        {
                            Thread.Sleep(5000);
                            if (iSEM.GetStageIs() == 0)
                            {
                                break;
                            }
                        }
                        arg.Message = "移动到新(" + x1.ToString() + "," + y1.ToString() + ")位置失败";
                        arg.State = true;
                        SendMsg("1-7");
                    }
                    else
                    {
                        arg.Message = "样品台移动失败";
                        arg.State = false;
                        SendMsg("1-7");
                        return false;
                    }
                }
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }

                //11.自动工具样品类型参数确定是否需要PT沉积
                if (m_MsParam.PT)
                {
                    //1. 根据客户PT沉积坐标控制FIB调整到中心位置？？？？？？？
                    //第10步已经移动好位置
                    //2. 验证移动准确性：获取当前FIB中心位置坐标，与客户返回坐标对比，验证是否一定正确
                    x0 = iSEM.GetStageAtX();
                    y0 = iSEM.GetStageAtY();
                    if (Math.Abs(x0 - x1) > fMin && Math.Abs(y0 - y1) > fMin)
                    {
                        arg.Message = "目标位置(" + x0.ToString() + "," + y0.ToString() + ")移动失败";
                        arg.State = false;
                        SendMsg("1-8");
                        return false;
                    }
                    arg.State = true;
                    arg.Message = "目标位置(" + x0.ToString() + "," + y0.ToString() + ")移动成功";
                    SendMsg("1-8");
                    //判断是否停止进程
                    if (key_stop)
                    {
                        return false;
                    }

                    //3. 根据坐标进行PT沉积   
                    if (!PTWork())
                    {
                        arg.Message = "PT沉积失败";
                        arg.State = false;
                        SendMsg("1-9");
                        return false;
                    }
                    arg.State = true;
                    arg.Message = "PT沉积成功";
                    SendMsg("1-9");
                    //判断是否停止进程
                    if (key_stop)
                    {
                        return false;
                    }

                }
            }

            //12.根据梯形坐标控制FIB调整到中心位置
            //13.验证移动准确性：获取当前FIB中心位置坐标，与客户返回坐标对比，验证是否移动正确
            //以上两步已经将程序移动到11内部去做

            //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-10");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 14. FIB切割
        /// </summary>
        /// <returns></returns>
        public bool FIBCross()
        {
            int state = 0;
            //切之前拍照保存，，
            String fileName31 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName31;
            arg.Picture_Information.Picture_FullPath = fileName31;
            arg.Picture_Information.Work_Status = "FIB";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(1000);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(1000);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(1000);
            if (!GetImage(ImageMode.FIB, fileName31))
            {
                arg.Message = "FIB切割前拍照失败";
                arg.State = false;
                SendMsg("1-11");
                return false;
            }
            arg.State = true;
            arg.Message = "FIB切割前拍照成功";
            SendMsg("1-11");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

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

            //3.控制FIB拍照600X
            //底层没有控制方法。
            //4.保存图片
            String fileName32 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName32;
            arg.Picture_Information.Picture_FullPath = fileName32;
            arg.Picture_Information.Work_Status = "FIB";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(1000);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(1000);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(1000);
            if (!GetImage(ImageMode.FIB, fileName32))
            {
                arg.Message = "FIB切割后拍照失败";
                arg.State = false;
                SendMsg("1-13"); 
                return false;
            }
            arg.State = true;
            arg.Message = "FIB切割后拍照成功";
            SendMsg("1-13");

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

            //5.验证切割准确性：与切割前对比，如果对比误差大，则停止自动执行，进行报警
            wr.Img_Cut_Success(fileName31, fileName32, out state);
            if(state == 0)
            {
                arg.Message = "FIB切割校验失败";
                arg.State = false;
                SendMsg("1-14");
                return false;
            }
            arg.State = true;
            arg.Message = "FIB切割校验成功";
            SendMsg("1-14");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //6.设置FIB解冻：先读取状态，如果冻结状态则进行解冻
            //拍完照自动解冻，这里不做处理。
            return true;
        }

        /// <summary>
        /// 16.自动调整SEM找到切割位置，这里不是简单的拉直旋转
        /// </summary>
        /// <returns></returns>
        public bool FindCross()
        {
            float x0 = 0, y0 = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
            float angle = 0;
            int direction = 0;
            int state = 0;
            //切换到SEM模式
            if (!iSEM.CmdFIBModeSEM())
            {
                arg.Message = "SEM模式切换失败";
                arg.State = false;
                SendMsg("1-16");
                return false;
            }
            arg.State = true;
            arg.Message = "SEM模式切换成功";
            SendMsg("1-16");
            arg.Picture_Information.Work_Status = "SEM";
            Thread.Sleep(10000);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //1.控制SEM放大到300倍
            if (!iSEM.SetSEMVoltage(m_MsParam.Location_Voltage))
            {
                arg.Message = "电压设置" + m_MsParam.Location_Voltage.ToString("0.0") + "失败";
                arg.State = false;
                SendMsg("1-17");
                return false;
            }
            if (!iSEM.SetMagnification(m_measureFile.MParam.Location_Magnification/2))
            {
                arg.Message = "放大" + (m_measureFile.MParam.Location_Magnification / 2).ToString("0.0") + "倍失败";
                arg.State = false;
                SendMsg("1-17");
                return false;
            }
            arg.State = true;
            arg.Message = "放大" + (m_measureFile.MParam.Location_Magnification/2).ToString("0.0") + "倍成功";
            SendMsg("1-17");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //2.控制SEM自动对焦、亮度、对比度-接口,,将自动对焦提出单独函数调用
            if (ImageFocus("1-18"))
            {
                arg.Message = "自动对焦完成";
                arg.State = true;
                SendMsg("1-18");
            }
            else
            {
                arg.Message = "自动对焦失败";
                arg.State = false;
                SendMsg("1-18");
            }
            Thread.Sleep(5000);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //3.控制SEM拍照
            String fileName4 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName4;
            arg.Picture_Information.Picture_FullPath = fileName4;
            arg.Picture_Information.Work_Status = "SEM";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(1000);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(1000);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(1000);
            if (!GetImage(ImageMode.SEM, fileName4))
            {
                arg.State = false;
                arg.Message = "SEM拍照失败";
                SendMsg("1-19");
                return false;
            }
            arg.State = true;
            arg.Message = "SEM拍照成功";
            SendMsg("1-19");

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

            //4.将照片传给客户，获取偏移坐标，以及偏移角度
            //5.根据坐标控制SEM移动到切孔位置，居中
            //这里是否用到拉直操作，我没有加
            if (DialogResult.Yes == MessageBox.Show("是否手动移动样品台到指定位置？\n如果点击取消则会调用Web接口。", "确认消息", MessageBoxButtons.YesNo))
            {
                arg.State = true;
                arg.Message = "样品台移动到指定位置";
                SendMsg("1-20");
            }
            else
            {
                wr.Img_Center_Position_OffsetAngle_Direction(fileName4, m_MsParam.SampleName, 
                    m_MsParam.Firm, out x1, out y1, out angle, out direction, out state);
                if (state == 1)
                {
                    //拉直操作
                    iSEM.SetScanRotationOn();
                    Thread.Sleep(1000);
                    iSEM.SetScanRotation(angle);
                    Thread.Sleep(5000);

                    //Straightening(angle, 65, 65, x1, y1, ref x2, ref y2);
                    //1. 根据客户PT沉积坐标控制FIB调整到中心位置？？？？？？？
                    if (!iSEM.MoveStageXY(x2, y2))
                    {
                        arg.State = false;
                        arg.Message = "移动到新(" + x1.ToString() + "," + y1.ToString() + ")位置失败";
                        SendMsg("1-20");
                        return false;
                    }
                    //判断是否移动完成
                    while (true)
                    {
                        Thread.Sleep(5000);
                        if (iSEM.GetStageIs() == 0)
                        {
                            break;
                        }
                    }
                    arg.State = true;
                    arg.Message = "移动到新(" + x2.ToString() + "," + y2.ToString() + ")位置失败";
                    SendMsg("1-20");
                    
                }
                else
                {
                    arg.Message = "样品台移动失败";
                    arg.State = false;
                    SendMsg("1-20");
                    return false;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //6.验证移动准确性：获取当前SEM中心位置坐标，与客户返回坐标对比，验证是否移动正确
            x0 = iSEM.GetStageAtX();
            y0 = iSEM.GetStageAtY();
            if (Math.Abs(x0 - x1) > fMin && Math.Abs(y0 - y1) > fMin)
            {
                arg.Message = "位置校验失败";
                arg.State = false;
                SendMsg("1-21");
                return false;
            }
            arg.State = true;
            arg.Message = "位置校验成功";
            SendMsg("1-21");

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

            return true;
        }

        /// <summary>
        /// 17.自动控制SEM拍截面照
        /// </summary>
        /// <returns></returns>
        public bool ShotSection(ref String image18)
        {
            float x0 = 0, y0 = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
            int state = 0;


            //1、放大6000倍,放大倍数参数photograph_
            if (!iSEM.SetSEMVoltage(m_MsParam.Photograph_Voltage))
            {
                arg.Message = "电压设置" + m_MsParam.Photograph_Voltage.ToString("0.0") + "失败";
                arg.State = false;
                SendMsg("1-22");
                return false;
            }
            if (!iSEM.SetMagnification(m_MsParam.Photograph_Magnification))
            {
                arg.Message = "放大倍数调整失败";
                arg.State = false;
                SendMsg("1-22");
                return false;
            }
            arg.Message = "放大倍数调整成功";
            arg.State = true;
            SendMsg("1-22");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //2.控制SEM自动对焦、亮度、对比度-接口
            if (ImageFocus("1-23"))
            {
                arg.Message = "自动对焦完成";
                arg.State = true;
                SendMsg("1-23");
            }
            else
            {
                arg.Message = "自动对焦失败";
                arg.State = false;
                SendMsg("1-23");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //3、设置SEM补偿角度
            if (!TiltCorrection(m_measureFile.MParam.Correction_Angle))
            {
                arg.Message = "设置SEM进行角度补偿" + m_measureFile.MParam.Correction_Angle.ToString("0") + "度失败";
                arg.State = false;
                SendMsg("1-24");
                return false;
            }
            arg.State = true;
            arg.Message = "设置SEM进行角度补偿" + m_measureFile.MParam.Correction_Angle.ToString("0") + "度成功";
            SendMsg("1-24");
            Thread.Sleep(5000);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //4、拍照，5、保存照片
            String fileName5 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName5;
            arg.Picture_Information.Picture_FullPath = fileName5;
            arg.Picture_Information.Work_Status = "SEM";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(1000);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(1000);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(1000);
            if (!GetImage(ImageMode.SEM, fileName5))
            {
                arg.Message = "SEM拍照失败";
                arg.State = false;
                SendMsg("1-25");
                return false;
            }
            arg.State = true;
            arg.Message = "SEM拍照成功";
            SendMsg("1-25");
            Thread.Sleep(3000);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //6、获取偏移坐标，7、移动到位
            if (DialogResult.Yes == MessageBox.Show("是否手动移动样品台到指定位置？\n如果点击取消则会调用Web接口。", "确认消息", MessageBoxButtons.YesNo))
            {
                arg.Message = "样品台移动到指定位置";
                arg.State = true;
                SendMsg("1-26");
            }
            else
            {
                //8,图像T形
                wr.Img_Trapezoid_Top_Center_Position(fileName5, out x1, out y1, out state);
                //接口返回像素，*pixelsize,得到坐标点。判断移动方式
                if (state == 1)
                {
                    //1. 根据客户PT沉积坐标控制FIB调整到中心位置？？？？？？？
                    if (!iSEM.MoveStageXY(x1, y1))
                    {
                        arg.Message = "移动到新(" + x1.ToString() + "," + y1.ToString() + ")位置失败";
                        arg.State = false;
                        SendMsg("1-26");
                        return false;
                    }
                    //判断是否移动完成
                    while (true)
                    {
                        Thread.Sleep(5000);
                        if (iSEM.GetStageIs() == 0)
                        {
                            break;
                        }
                    }
                    arg.State = true;
                    arg.Message = "移动到新(" + x1.ToString() + "," + y1.ToString() + ")位置失败";
                    SendMsg("1-26");
                }
                else
                {
                    arg.Message = "样品台移动失败";
                    arg.State = false;
                    SendMsg("1-26");
                    return false;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //8、验证移动准确性
            x0 = iSEM.GetStageAtX();
            y0 = iSEM.GetStageAtY();
            if (Math.Abs(x0 - x1) > fMin && Math.Abs(y0 - y1) > fMin)
            {
                arg.Message = "位置校验失败";
                arg.State = false;
                SendMsg("1-27");
                return false;
            }
            arg.State = true;
            arg.Message = "位置校验成功";
            SendMsg("1-27");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //9、-10不操作
            //11、自动对焦。与之前操作相同
            if (ImageFocus("1-28"))
            {
                arg.Message = "自动对焦完成";
                arg.State = true;
                SendMsg("1-28");
            }
            else
            {
                arg.Message = "自动对焦失败";
                arg.State = false;
                SendMsg("1-28");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            Thread.Sleep(2000);
            //12拍照
            String fileName6 = data_path + "\\" + m_nWorkHoleNo.ToString() + "Hole" + ImageName6;
            arg.Picture_Information.Picture_FullPath = fileName6;
            arg.Picture_Information.Work_Status = "SEM";
            arg.Picture_Information.Work_Voltage = iSEM.GetSEMVoltage();
            Thread.Sleep(1000);
            arg.Picture_Information.Magnification = iSEM.GetMagnification();
            Thread.Sleep(1000);
            arg.Picture_Information.Work_Distance = iSEM.GetWorkingDistance();
            Thread.Sleep(1000);
            if (!GetImage(ImageMode.SEM, fileName6))
            {
                arg.Message = "SEM拍照失败";
                arg.State = false;
                SendMsg("1-29");
                return false;
            }
            arg.State = true;
            image18 = fileName6;
            arg.Message = "SEM拍照成功";
            SendMsg("1-29");
            Thread.Sleep(3000);
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
            //14光束复位和Rotation关闭开关
            iSEM.SetScanRotationOff();
            Thread.Sleep(1000);
            iSEM.SetBeamShiftX(0);
            Thread.Sleep(1000);
            iSEM.SetBeamShiftY(0);
            Thread.Sleep(3000);
            arg.Message = "光束复位成功";
            arg.State = true;
            SendMsg("1-30");
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }
            return true;
        }

        //第一个孔的测试过程
        public bool FirstHole()
        {
            MeasureData.CutHole firstHole = m_cutHoles[0];

            //首先默认为SEM模式
            arg.Picture_Information.Work_Status = "SEM";
            //12.根据样品类型参数确定是否需要PT沉积，控制PT针插入
            if (m_MsParam.Is_Photograph == false && m_MsParam.PT == true)
            {
                if (!InsertPT())
                {
                    arg.Message = "插入PT针失败";
                    arg.State = false;
                    SendMsg("1-0");
                    return false;
                }
                arg.State = true;
                arg.Message = "插入PT针成功";
                SendMsg("1-0");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }


            //13. 自动 定位功能
            if (!GetPoistion(true))
            {
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //14.自动控制FIB切割
            if (m_MsParam.Is_Photograph == false && m_MsParam.PT == true)
            {
                if (!FIBCross())
                {
                    return false;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //15.根据样品类型决定是否撤出PT针
            if (m_MsParam.Is_Photograph == false && m_MsParam.PT == true)
            {
                if (!RetractPT())
                {
                    arg.Message = "撤出PT针失败";
                    arg.State = false;
                    SendMsg("1-15");
                    return false;
                }
                arg.State = true;
                arg.Message = "撤出PT针成功";
                SendMsg("1-15");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            // 16.找到切割位置
            if (m_MsParam.Is_Photograph == false)
            {
                if (!FindCross())
                {
                    return false;
                }
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
            }

            //将过程17最后的拍照图片提出给18步进行调用
            String img18 = "";
            //17.自动控制SEM拍截面照
            if (!ShotSection(ref img18))
            {
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //18.自动层高分析
            if (m_MsParam.Is_Photograph == false)
            {
                float size = iSEM.GetPixelSize();
                float mag = iSEM.GetMagnification();
                int state = 0;
                wr.Img_Measure_Size(img18, mag, size, out state);
                if (state == 0)
                {
                    arg.Message = "测量尺寸失败";
                    arg.State = false;
                    SendMsg("1-31");
                    return false;
                }
                arg.State = true;
                arg.Message = "测量尺寸成功";
                SendMsg("1-31");
            }
            #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

            return true;
        }

        //非第一个孔的测试过程
        public bool OtherHole()
        {
            //首先默认为SEM模式
            arg.Picture_Information.Work_Status = "SEM";
            //12.根据样品类型参数确定是否需要PT沉积，控制PT针插入
            if (m_MsParam.Is_Photograph == false && m_MsParam.PT == true)
            {
                if (!InsertPT())
                {
                    arg.Message = "插入PT针失败";
                    SendMsg("1-0");
                    return false;
                }
                arg.Message = "插入PT针成功";
                SendMsg("1-0");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //13. 自动 定位功能
            if (!GetPoistion(false))
            {
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //14.自动控制FIB切割
            if (m_MsParam.Is_Photograph == false && m_MsParam.PT == true)
            {
                if (!FIBCross())
                {
                    return false;
                }
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //15.根据样品类型决定是否撤出PT针
            if (m_MsParam.Is_Photograph == false && m_MsParam.PT == true)
            {
                if (!RetractPT())
                {
                    arg.Message = "撤出PT针失败";
                    SendMsg("1-15");
                    return false;
                }
                arg.Message = "撤出PT针成功";
                SendMsg("1-15");
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            // 16.找到切割位置
            if (m_MsParam.Is_Photograph == false)
            {
                if (!FindCross())
                {
                    return false;
                }
                //判断是否停止进程
                if (key_stop)
                {
                    return false;
                }
            }

            //将过程17最后的拍照图片提出给18步进行调用
            String img18 = "";
            //17.自动控制SEM拍截面照
            if (!ShotSection(ref img18))
            {
                return false;
            }
            
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //18.自动层高分析
            if (m_MsParam.Is_Photograph == false)
            {
                float size = iSEM.GetPixelSize();
                float mag = iSEM.GetMagnification();
                int state = 0;
                wr.Img_Measure_Size(img18, mag, size, out state);
                if (state == 0)
                {
                    arg.Message = "测量尺寸失败";
                    SendMsg("1-31");
                    return false;
                }
                arg.Message = "测量尺寸成功";
                SendMsg("1-31");
            }

            #region 测试程序
            //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);


            //SendMsg("所有图结束");
            #endregion
            return true;
        }

        //测试完第一个孔后的样品台初始化操作。
        //再调用CommonWork执行非第一个孔的测试过程
        public bool OtherHole_Init()
        {
            //SendMsg("当前切孔号为"+ m_nWorkHoleNo.ToString());
            CutHole currentHole = m_cutHoles[m_nWorkHoleNo];
            
            #region 1. 初始化
            //1. 设置FIB解冻：先读取状态，如果冻结则进行解冻
            //读取图像冻结状态
            float ffrozen = iSEM.GetImageFrozen();
            if (ffrozen == float.NaN)
            {
                return false;
            }

            if (DialogResult.Yes == MessageBox.Show("样品台可以旋转恢复到水平吗？", "确认消息", MessageBoxButtons.YesNo))
            {
                //SendMsg("样品台恢复到水平");
                //return true;
            }
            else
            {
                //SendMsg("禁止样品台恢复到水平");
                return false;
            }
            //判断是否停止进程
            if (key_stop)
            {
                return false;
            }

            //2. 调节样品1号孔的样品台6轴坐标
            //3. 将样品1号孔坐标2存入数据库
            //4. 控制样品台T轴归0，R轴变为坐标1、Z/M轴作为坐标2保存不变
            if (!iSEM.SetStageGotoT(0))
            {
                return false;
            }
            while (true)
            {
                Thread.Sleep(10000);

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

            //5. 获取光镜2号孔XY坐标
            //SendMsg("移动到"+m_nWorkHoleNo+"号孔位置:(" + currentHole.Position.X.ToString()+","+currentHole.Position.Y.ToString()+")");

            //6. 根据光镜坐标控制样品台移动
            if (!iSEM.MoveStageXY(currentHole.Position.X, currentHole.Position.Y))
            {
                //SendMsg("移动失败");
                return false;
            }
            while (true)
            {
                Thread.Sleep(10000);

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

            //7. 控制样品台，调整T轴54度、M/Z/R轴不变
            if (DialogResult.Yes == MessageBox.Show("样品台可以旋转吗？", "确认消息", MessageBoxButtons.YesNo))
            {
                //SendMsg("样品台旋转");
                //return true;
            }
            else
            {
                //SendMsg("禁止样品台旋转");
                return false;
            }

            if (!iSEM.SetStageGotoT(54))
            {
                return false;
            }
            while (true)
            {
                Thread.Sleep(10000);

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

            //SendMsg("拉直操作");

            #endregion

            //其他操作与第一个孔相同
            if (!OtherHole())
            {
                return false;
            }

            return true;
        }

        //角度补偿
        public bool TiltCorrection(float a_fAngle)
        {
            //记录原来电镜的状态
            // bool bTilt = false;
            //float fOldTilt = iSEM.GetTiltCorrection();
            //if (fOldTilt == float.NaN)
            //{
            //    return false;
            //}
            //else if (fOldTilt == 1)
            //{
            //    bTilt = true;
            //}
            //else if (fOldTilt == 0)
            //{
            //    bTilt = false;
            //}

            //float fOldAngle = iSEM.GetTiltAngle();
            //if (fOldAngle == float.NaN)
            //{
            //    return false;
            //}

            //开启校正
            //SendMsg("开启校正");
            if (!iSEM.SetTiltAngleOn())
            {
                return false;
            }

            //设置校正角度
            //if (!iSEM.SetTiltAngle(fOldAngle))
            //{
            //    return false;
            //}

            //恢复原始状态
            //SendMsg("校正角度"+ a_fAngle.ToString());
            if (!iSEM.SetTiltAngle(a_fAngle))
            {
                return false;
            }
            //if (bTilt)
            //{
            //    if (!iSEM.SetTiltCorrectionOn())
            //    {
            //        return false;
            //    }
            //}
            //else
            //{
            //    if (!iSEM.SetTiltCorrectionOff())
            //    {
            //        return false;
            //    }
            //}
            return true;
        }

        //拍图
        public bool GetImage(ImageMode a_mode, String a_fileName)
        {
            //1. 图像解冻
            float foldFrozen = iSEM.GetImageFrozen();
            if (foldFrozen == float.NaN)
            {
                return false;
            }

            if (!iSEM.ImageLive())
            {
                return false;
            }

            //2. 确认图像模式
            if (ImageMode.SEM == a_mode)
            {
                if (!iSEM.CmdFIBModeSEM())
                {
                    return false;
                }
            }
            else if (ImageMode.FIB == a_mode)
            {
                if (!iSEM.CmdFIBModeFIB())
                {
                    return false;
                }
            }
            else
            {
                return false;
            }

            //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.GrabImage(a_fileName, 0, 0, width, height, 0))
            {
                return false;
            }

            //5. 恢复初始状态
            if (foldFrozen == 0)
            {
                if (!iSEM.ImageLive())
                {
                    return false;
                }
            }
            else if (foldFrozen == 1)
            {
                if (!iSEM.ImageFrozen())
                {
                    return false;
                }
            }

            return true;
        }

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

            if (a_param == null)
            {
                return false;
            }

            string path = a_param.Path;
            if (!Directory.Exists(path))
            {
                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);

            //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(8000);

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

                String fileName = path_coarse + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(ImageMode.SEM, fileName))
                {
                    return false;
                }
                SendMsg(step_code);   
            }

            //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);
                iSEM.SetWorkingDistance((float)(cWd * 0.00000001));
                arg.Picture_Information.Work_Distance = (float)(cWd * 0.00000001);
                Thread.Sleep(8000);

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

                String fileName = path_fine + "\\" + cWd.ToString() + ".tif";
                arg.Picture_Information.Picture_FullPath = fileName;
                if (!GetImage(ImageMode.SEM, fileName))
                {
                    return false;
                }
                SendMsg(step_code);

            }

            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 void 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("对焦失败。");
            }
        }
    }
}