OTS/OTSIncAMeasureApp/1-OTSMeasure/OTSMeasureDisplayResult.cs


using OTSModelSharp;
using OTSDataType;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using static OTSDataType.otsdataconst;
using static OTSModelSharp.STMSampleResultData;

namespace OTSMeasureApp
{
    class OTSMeasureDisplayResult
    {
        NLog.Logger log ;
        public enum ProgressState
        {
           
            MeasureCheckReport = 1,
            MeasureResult = 2
        }

        #region 变量生成汇总
        OTSIncAMeasureAppForm m_MeasureApp = null;
      
       
      
       
        
        //样品台窗口对象
        public OTSSamplespaceWindow m_OTSSamplespaceWindow = null;
       
        //测量进度信息窗口对象
        public MeasureCheckResultInfoWindow m_MeasureCheckReportInfoWindow = null;
        //测量结果信息窗口对象
        public OTSMeasureResultWindow m_OTSMeasureResultWindow = null;
        //在窗体TAB测量状态中显示BSE图
        public OTSMeasureStatusWindow m_OTSMeasureStatusWindow = null;
        public System.ComponentModel.BackgroundWorker m_bgWorker;
      
        //开始时间
        static string m_StartTimePara = "";
        //当前测试样品名称
        static string m_CurrentSampleName = "";
        ST_MSTMsg MeasureResultMsrData;
        //已完成帧图的绘制 根据位置-判断相差范围  四舍五入返回的数值有偏差
        static int minRange = -100;
        static int maxRange = 100;
        #endregion

        #region 构造方法
        public OTSMeasureDisplayResult( OTSIncAMeasureAppForm m_MeasureApps, BackgroundWorker a_bgWorker)
        {
            log = NLog.LogManager.GetCurrentClassLogger();
          
                m_MeasureApp = m_MeasureApps;
               
                m_OTSSamplespaceWindow = m_MeasureApps.m_SamplepaceWindow;
                m_OTSMeasureResultWindow = m_MeasureApp.m_MeasureRetWindow;
                m_OTSMeasureStatusWindow = new OTSMeasureStatusWindow(m_MeasureApp);
               
                Control.CheckForIllegalCrossThreadCalls = false;

                //测量结束信息窗口对象
                m_MeasureCheckReportInfoWindow = new MeasureCheckResultInfoWindow();
                m_bgWorker = a_bgWorker;
                //设置报告更新是否可用
                m_bgWorker.WorkerReportsProgress = true;
                //设置支持取消操作是否可用
                m_bgWorker.WorkerSupportsCancellation = true;
             
                m_bgWorker.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker_ProgressChanged);
                m_bgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker_RunWorkerCompleted);
              
          
        }
        #endregion

        #region 修改窗体控件的响应事件_ProgressChanged
        //这里就是通过响应消息，来处理界面的显示工作
        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            try
            {
              
                if (e.ProgressPercentage == (int)ProgressState.MeasureCheckReport)
                {
                    
                        MeasureResultInfo(MeasureResultMsrData);
                   
                }
                //测量结果
                if (e.ProgressPercentage == (int)ProgressState.MeasureResult)
                {
                   
                        if (m_OTSMeasureResultWindow == null)
                        {
                            //实例窗体
                            m_OTSMeasureResultWindow = m_MeasureApp.m_MeasureRetWindow;
                        }
                        //设置工作样品
                        m_MeasureApp.m_ProjParam.SetWorkSample(OTSSamplespaceWindow.m_SampleSelectName);
                        //获取工作样品信息
                        COTSSample WSample = m_MeasureApp.m_ProjParam.GetWorkSample();
                        CMsrDisplayResults cMsrResultsClr = WSample.GetMsrResults();
                        //获取结果文件 颗粒列表信息
                        List<CMsrResultItem> cMsrResultItemClrList = cMsrResultsClr.GetResultItems();
                        //根据编号获取分类名称
                        List<CMsrResultItem> cMsrResultItemClrListTemp = cMsrResultItemClrList;
                        //设置测量状态数据列表
                        SetMeasureListInfo(cMsrResultItemClrList);
                   
                }

            }
            catch (Exception ex)
            {
                log.Error("OTSIncAMeasureApp_backgroundWorker_ProgressChanged:--Open the measurement results list window - error log:" + ex.ToString());
            }
        }
        #endregion

        #region 处理完成的响应事件_RunWorkerCompleted
        //这里是后台工作完成后的消息处理，可以在这里进行后续的处理工作。
        private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //m_bgWorker.CancelAsync();

            //m_bgWorker = null;
        }
        #endregion



        #region 判断窗口是否已经打开
        //判断窗口是否已经打开
        private bool CheckFormIsOpen(string Forms)
        {
            bool bResult = false;
            foreach (Form frm in Application.OpenForms)
            {
                if (frm.Name == Forms)
                {
                    bResult = true;
                    break;
                }
            }
            return bResult;
        }
        #endregion

        #region 打开测量结果窗口
        /// <summary>
        /// 打开测量结果窗口
        /// </summary>
        public void MeasureResultInfo(ST_MSTMsg sMSR)
        {
            //打开测量结果窗体
            if (m_MeasureCheckReportInfoWindow.IsDisposed)
            {
                m_MeasureCheckReportInfoWindow = new MeasureCheckResultInfoWindow();
            }
            m_MeasureCheckReportInfoWindow.Activate();
            m_MeasureCheckReportInfoWindow.Show();
            SetMeasureResultInfo(sMSR);
        }
        #endregion

        #region 显示BSE图片
        public void OTSMeasureStatusWindowFun(int width, int height, byte[] ImageData, OTSIncAMeasureAppForm m_MeasureApps)
        {
            //设置图像数据与状态
            OTSMeasureStatusWindow.bfResult = true;
            m_MeasureApps.m_MessureStatuWindow.bBseData = ImageData;
            //获取灰度图数据
            double[] dGrayLevelData = new double[255];
            dGrayLevelData = OTSImageData.GetStaticGaryData(ImageData, dGrayLevelData);
            m_MeasureApps.m_MessureStatuWindow.dGrayLevelData = dGrayLevelData;
            if (m_MeasureApps.m_MessureStatuWindow.panelXray.Visible)
            {
                m_MeasureApps.m_MessureStatuWindow.panelXray.Visible = false;
            }
            //删除点标记
            m_MeasureApps.m_MessureStatuWindow.DelElementPointGDIObjects();
            //显示BSE图
            m_MeasureApps.m_MessureStatuWindow.pbBSEImage.Show();
  
            //显示BSE图
            m_MeasureApps.m_MessureStatuWindow.ShowImage(width, height, ImageData);
        }
        #endregion

        #region 隐藏BSE图片
   
        #endregion

        #region 初始窗口对象
       
        int intFlag = 0;
        public void RunThreadLoadEvent()
        {
            if (intFlag == 0)
            {
                m_bgWorker.RunWorkerAsync();
                intFlag++;
            }
        }
        #endregion
        #region 设置测量状态列表数据
        /// <summary>
        /// 设置测量状态列表数据
        /// </summary>
        /// <param name="stratTime"></param>
        public void SetMeasureListInfo(IList list)
        {
            //设置开始时间
            if (list != null)
            {
                //获取测量状态Grid中的数据list
                m_OTSMeasureResultWindow.SetMeasureListInfo(list);
            }
        }
        #endregion
        #region 设置开始时间
        /// <summary>
        /// 设置开始时间
        /// </summary>
        /// <param name="stratTime"></param>
        public void SetStartTime(string stratTime)
        {
            //设置开始时间
            if (stratTime != null)
            {
                if (stratTime != "")
                {
                    m_OTSMeasureResultWindow.SetStartTime(stratTime);
                }
            }
        }
        #endregion

        #region 设置结束时间
        /// <summary>
        /// 设置结束时间
        /// </summary>
        /// <param name="SetEndTime"></param>
        public void SetEndTime(string endTime)
        {
            //设置开始时间
            if (endTime != null)
            {
                if (endTime != "")
                {
                    //设置结束时间
                    m_MeasureCheckReportInfoWindow.SetEndTime(endTime);
                }
            }
        }
        #endregion

        #region 设置测量结束窗体中信息内容
        public void SetMeasureResultInfo(ST_MSTMsg SMsrData)
        {
            //设置开始时间
            string startTime = SMsrData.STMThreadStu.SMsrCompleteData.csMsrStartTime;
            //设置结束时间
            string endTime = SMsrData.STMThreadStu.SMsrCompleteData.csMsrEndTime;
            //设置测量数
            int completeSampleCount = SMsrData.STMThreadStu.SMsrCompleteData.iMsrCompleteSampleCount;
            //设置帧图数
            int completeFieldCount = SMsrData.STMThreadStu.SMsrCompleteData.iMsrCompleteFieldCount;
            //颗粒数
            int particleCount = SMsrData.STMThreadStu.SMsrCompleteData.iParticleCount;
            //用时
            TimeSpan measureTime = SMsrData.STMThreadStu.SMsrCompleteData.MsrUsedTime;
            string measureState = string.Empty;
            OTSCommon.Language lan = new OTSCommon.Language();
            Hashtable table= lan.GetNameTable("OTSMeasureResultWindow");

            //状态
            //switch (SMsrData.STMThreadStu.SMsrCompleteData.MsrStatus)
            switch (SMsrData.STMThreadStu.iMsrStatu)
            {
                case OTS_MSR_THREAD_STATUS.COMPLETED:
                    measureState = table["state1"].ToString();
                    break;
                case OTS_MSR_THREAD_STATUS.FAILED:
                    measureState = table["state2"].ToString();
                    break;
                case OTS_MSR_THREAD_STATUS.STOPPED:
                    measureState = table["state3"].ToString();
                    break;
            }
            //设置测量结果窗体信息
            string measureTimes = string.Empty;
            m_MeasureCheckReportInfoWindow.SetMeasureStateInfo(measureState, completeSampleCount, completeFieldCount, particleCount, startTime, measureTime, endTime, ref measureTimes);
        }
        #endregion

        #region 设置测量用时
        public void SetMeasureTime(TimeSpan tSpan)
        {
            m_OTSMeasureResultWindow.SetMeasureTime(tSpan);
        }
        #endregion

        #region 设置样品名称
        /// <summary>
        /// 设置样品名称
        /// </summary>
        /// <param name="SetSampleName"></param>
        public void SetSampleName(string sampleName)
        {
            //设置开始时间
            if (sampleName != null)
            {
                if (sampleName != "")
                {
                    CStageManage.SetWorkSampleAndWorkMeasure(sampleName);
                    double iWDistance = 0;
                    double dMagni = 0;
                    m_MeasureApp.m_ProjParam.GetWorkingSampleSEMData(ref iWDistance, ref dMagni);
                    
                    if (CMeasureThreadWrapper.DoRunType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                    {
                        m_OTSMeasureResultWindow.SetSampleName(sampleName);
                    }
                    m_OTSSamplespaceWindow.Invalidate();
                }
            }
        }
        #endregion

        #region 更改已完成测量的帧图状态
        public void ChangeDoneMeasureState(Point CurrentFIELDOTSPoint, Color changeColor)
        {
            //根据完成的测量帧图 更改帧图的完成状态
            if (OTSSamplespaceWindow.m_SingleGDIObjects != null)
            {
                if (OTSSamplespaceWindow.m_SingleGDIObjects.Count > 0)
                {
                    //已完成帧图的绘制 根据位置-判断相差范围  四舍五入返回的数值有偏差
                    int minTempRange = minRange;
                    int maxTempRange = maxRange;
                    int XOffset = 0;
                    int YOffset = 0;
                    //以放大倍数 获取当前倍数扫描尺寸 与100倍扫描尺寸的比例
                    int ScanFieldSize = m_MeasureApp.m_ProjParam.GetResultData().GetWorkingSample().GetSEMDataMsr().GetScanFieldSize();
                    int ScanFieldSize100 = m_MeasureApp.m_ProjParam.GetResultData().GetWorkingSample().GetSEMDataMsr().GetScanFieldSize100();
                    float Scale = Convert.ToSingle(ScanFieldSize100) / Convert.ToSingle(ScanFieldSize);
                    if (Scale > 0)
                    {
                        minTempRange = Convert.ToInt32(minTempRange / Scale);
                        maxTempRange = Convert.ToInt32(maxTempRange / Scale);
                    }
                    for (int i = OTSSamplespaceWindow.m_SingleGDIObjects.Count - 1; i >= 0; i--)
                    {
                        XOffset= OTSSamplespaceWindow.m_SingleGDIObjects[i].OTSX - CurrentFIELDOTSPoint.X;
                        YOffset = OTSSamplespaceWindow.m_SingleGDIObjects[i].OTSY - CurrentFIELDOTSPoint.Y;
                        if ((minTempRange < XOffset) && (XOffset < maxTempRange) && (minTempRange < YOffset) && (YOffset < maxTempRange))
                        {
                            //修改完成状态
                            OTSSamplespaceWindow.m_SingleGDIObjects[i].SelColor = changeColor;
                            break;
                        }
                    }
                }
            }
        }
        public static int ChangeCompleteFieldMeasureState(List<Point> CompleteFieldList, Color changeColor, OTSIncAMeasureAppForm m_MeasureApp)
        {


            int CompleteCount = 0;
            //根据完成的测量帧图 更改帧图的完成状态
            if (OTSSamplespaceWindow.m_SingleGDIObjects != null)
            {
                if (OTSSamplespaceWindow.m_SingleGDIObjects.Count > 0)
                {
                    //已完成帧图的绘制 根据位置-判断相差范围  四舍五入返回的数值有偏差
                    int minTempRange = minRange;
                    int maxTempRange = maxRange;
                    int XOffice = 0;
                    int YOffice = 0;
                    //以放大倍数 获取当前倍数扫描尺寸 与100倍扫描尺寸的比例
                    int ScanFieldSize = m_MeasureApp.m_ProjParam.GetResultData().GetWorkingSample().GetSEMDataMsr().GetScanFieldSize();
                    int ScanFieldSize100 = m_MeasureApp.m_ProjParam.GetResultData().GetWorkingSample().GetSEMDataMsr().GetScanFieldSize100();
                    float Scale = ScanFieldSize100 / ScanFieldSize;
                    minTempRange = Convert.ToInt32(minTempRange / Scale);
                    maxTempRange = Convert.ToInt32(maxTempRange / Scale);
                    for (int y = 0; y < CompleteFieldList.Count; y++)
                    {
                        for (int x = OTSSamplespaceWindow.m_SingleGDIObjects.Count - 1; x >= 0; x--)
                        {
                            XOffice = Convert.ToInt32((OTSSamplespaceWindow.m_SingleGDIObjects[x].OTSX - CompleteFieldList[y].X)/Scale);
                            YOffice = Convert.ToInt32((OTSSamplespaceWindow.m_SingleGDIObjects[x].OTSY - CompleteFieldList[y].Y)/ Scale);
                            if ((minTempRange < XOffice) && (XOffice < maxTempRange) && (minTempRange < YOffice) && (YOffice < maxTempRange))
                            {
                                //修改完成状态
                                OTSSamplespaceWindow.m_SingleGDIObjects[x].SelColor = changeColor;
                                CompleteCount++;
                                break;
                            }
                        }
                    }
                }
            }
            return CompleteCount;
        }
        #endregion

        #region 测量状态进度窗口
        public void MeasureStateProgressInfo(SAMPLEFIELDDATA FieldData)
        {
            //样品测量中的总帧图数
            int MeasureFieldTotalCount = FieldData.iMeasureFieldCount;
            //样品测量中当前已测量的帧图数
            int CompleteFieldCount = FieldData.iCompleteFieldCount;
            int ParticleCount = FieldData.iSParticleCount;
            if (CompleteFieldCount >= 0 && MeasureFieldTotalCount >= 0)
            {
                m_bgWorker.ReportProgress((int)ProgressState.MeasureResult);
                //设置当前进度信息(当前Field数量与Field总数)
                m_OTSMeasureResultWindow.SetCurrentProgressInfo(CompleteFieldCount, MeasureFieldTotalCount, ParticleCount);
            }
        }
        #endregion

     

       

        #region 设置样品孔中BSE图像信息
        /// <summary>
        /// 设置样品孔中BSE图像信息
        /// </summary>
        /// <param name="ImageData">获取显示BSE的图片数据</param>
        /// <param name="width">图片宽度</param>
        /// <param name="height">图片高度</param>
        /// <param name="fieldPos">Field位置</param>
        public void SetHoleBSEImageData(byte[] ImageData, int width, int height, Point fieldPos)
        {
            m_MeasureApp.m_SamplepaceWindow.AddHoleBSEImageData(ImageData, width, height, fieldPos);
        }
        #endregion

        #region 测量方法
        //运行测量状态方法
        public void RunMeasureState(ST_MSTMsg SMsrData)
        {
            try
            {
                
                //消息枚举 测量状态、测量结果
                ENUM_MSG_TYPE dataType = SMsrData.iMsgType;
                //测量状态:开始状态、完成状态(测量停止、测量失败、测量完成)
                OTS_MSR_THREAD_STATUS msrStatus = SMsrData.STMThreadStu.iMsrStatu;
                //获取当前线程执行类型 1：测量 2：获取样品孔图片
                int runThreadType = CMeasureThreadWrapper.DoRunType;

                //获取需显示的grid信息
                OTSSamplePropertyInfo MeasureInfo = new OTSSamplePropertyInfo();
                m_MeasureApp.m_ProjParam.GetWorkSamplePerameter(m_MeasureApp.m_ProjParam.GetWorkSample(), ref MeasureInfo);

                switch (dataType)
                {
                    //测量线程状态
                    case ENUM_MSG_TYPE.MTHREADSTATUS:
                        switch (msrStatus)
                        {
                            //测量状态在进行中-测量开始
                            case OTS_MSR_THREAD_STATUS.INPROCESS:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {

                                    string startTime = SMsrData.STMThreadStu.csMsrStartTime;
                                    //设置开始时间
                                    m_StartTimePara = startTime;
                                     
                                }
                                //判断信息来源  拍摄样品孔图片 或是 测量开始 
                                if (m_MeasureApp.m_MessageStates == MessageState.ShotBSEPicture)
                                {
                                    //根据放大倍数、重新绘制帧图信息
                                    m_MeasureApp.m_SamplepaceWindow.showSingleInfo();
                                }
                                break;
                            //测量状态已完成
                            case OTS_MSR_THREAD_STATUS.COMPLETED:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    string inprocessEndTime = SMsrData.STMThreadStu.csMsrEndTime;
                                    SetMeasureResultInfo(SMsrData);
                                    MeasureResultMsrData = SMsrData;

                                    m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport, SMsrData);
                                    //激活跳转至报告程序按钮
                                    m_MeasureApp.rbPReport.Enabled = true;
                                    m_MeasureApp.rbReport.Enabled = true;
                                }
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNSampleHoleImage)
                                {
                                    SetRestoreWorkingDistanceAndMagnification();
                                }

                                //测量完成，更新Grid显示的测量信息
                                m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
                                break;
                            //测量状态已失败
                            case OTS_MSR_THREAD_STATUS.FAILED:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    string failedEndTime = SMsrData.STMThreadStu.csMsrEndTime;
                                    SetMeasureResultInfo(SMsrData);
                                    MeasureResultMsrData = SMsrData;
                                    m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport, SMsrData);
                                }
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNSampleHoleImage)
                                {
                                    SetRestoreWorkingDistanceAndMagnification();
                                }

                                //测量失败，更新Grid显示的测量信息
                                m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
                                break;
                            //测量状态已停止
                            case OTS_MSR_THREAD_STATUS.STOPPED:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    string stopEndTime = SMsrData.STMThreadStu.csMsrEndTime;
                                    //打开测量结果窗口
                                    SetMeasureResultInfo(SMsrData);
                                    MeasureResultMsrData = SMsrData;
                                    m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport, SMsrData);
                                    //激活跳转至报告程序按钮
                                    m_MeasureApp.rbPReport.Enabled = true;
                                    m_MeasureApp.rbReport.Enabled = true;
                                }
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNSampleHoleImage)
                                {
                                    SetRestoreWorkingDistanceAndMagnification();
                                }

                                //测量停止，更新Grid显示的测量信息
                                m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
                                break;
                        }
                        break;
                    //测量结果
                    case ENUM_MSG_TYPE.MSAMPLESTATUS:
                        //获取测量状态样品信息
                        OTS_MSR_SAMPLE_STATUS msrSampleStatu = SMsrData.STMSampleStu.iMsrSampleStatu;
                        switch (msrSampleStatu)
                        {
                            case OTS_MSR_SAMPLE_STATUS.INPROCESS:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    //获取样品名称
                                    string sampleName = SMsrData.STMSampleStu.cSampleName;
                                    //样品测量开始时间
                                    string csSampleMsrStartTime = SMsrData.STMSampleStu.csSampleMsrStartTime;
                                    //设置样品名称
                                    if (sampleName != null)
                                    {
                                        if (sampleName != "")
                                        {
                                            SetSampleName(sampleName);
                                            //设置开始时间
                                            SetStartTime(csSampleMsrStartTime);
                                            m_CurrentSampleName = sampleName;
                                        }
                                    }
                                    //切换样品
                                    m_MeasureApp.SwitchWSample(sampleName);
                                    //设置样品名称
                                    m_OTSMeasureResultWindow.SetSampleName(sampleName);

                                    
                                    //填充帧图信息
                                    OTSSamplespaceWindow.ChangeSampleFillSingleInfo(sampleName);
                                }
                                else if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNSampleHoleImage)
                                {
                                    //获取样品名称
                                    string sampleName = SMsrData.STMSampleStu.cSampleName;
                                    //设置样品名称
                                    if (sampleName == null)
                                    {
                                        if (sampleName.Equals(""))
                                        {
                                            if (m_MeasureApp.m_ProjParam.GetWorkSample() != null)
                                            {
                                                sampleName = m_MeasureApp.m_ProjParam.GetWorkSample().GetName();
                                            }
                                        }
                                    }
                                    SetSampleName(sampleName);
                                }
                                break;
                        }
                        break;
                    case ENUM_MSG_TYPE.MSAMPLERESULT:
                        //获取测量状态的Field与BSE信息
                        MSAMPLE_RET retDataType = SMsrData.STMSampleRetData.iRetDataType;

                        //判断测量状态提供Field与BSE信息
                        switch (retDataType)
                        {
                            case MSAMPLE_RET.BSE_DATA:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    //获取显示BSE的图片数据
                                    byte[] ImageData = SMsrData.STMSampleRetData.BSEData.lpBSEData;
                                    //图片宽度
                                    int width = SMsrData.STMSampleRetData.BSEData.iBSEDataWidth;
                                    //图片高度
                                    int height = SMsrData.STMSampleRetData.BSEData.iBSEDataHeight;
                                    //显示状态中的BSE图像控件
                                    if (!m_MeasureApp.m_MessureStatuWindow.pbBSEImage.Visible)
                                    {
                                        m_MeasureApp.m_MessureStatuWindow.pbBSEImage.Visible = true;
                                    }
                                    //调用测量状态TAB中窗体 显示BSE图片
                                    OTSMeasureStatusWindowFun(width, height, ImageData, m_MeasureApp);
                                 
                                  

                                }
                                else if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNSampleHoleImage)
                                {
                                    //获取显示BSE的图片数据
                                    byte[] ImageData = SMsrData.STMSampleRetData.BSEData.lpBSEData;
                                    //图片宽度
                                    int width = SMsrData.STMSampleRetData.BSEData.iBSEDataWidth;
                                    //图片高度
                                    int height = SMsrData.STMSampleRetData.BSEData.iBSEDataHeight;
                                    //Field位置
                                    Point fieldPos = SMsrData.STMSampleRetData.BSEData.pos;
                                    //设置样品孔中BSE图像信息
                                    SetHoleBSEImageData(ImageData, width, height, fieldPos);
                                }
                                break;
                            case MSAMPLE_RET.FIELD_DATA:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    //设置测量当前用时
                                    if (SMsrData.STMSampleRetData.SFieldData.TUsedTime != null)
                                    {
                                        SetMeasureTime(SMsrData.STMSampleRetData.SFieldData.TUsedTime);
                                    }

                                    MeasureStateProgressInfo(SMsrData.STMSampleRetData.SFieldData);
                                    ChangeDoneMeasureState(SMsrData.STMSampleRetData.SFieldData.FieldPos, Color.Green);
                                    m_OTSSamplespaceWindow.Invalidate();

                                }
                                break;
                            case MSAMPLE_RET.START_MSR_FIELD:
                                //当前线程执行类型 1：测量
                                if (runThreadType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
                                {
                                    ChangeDoneMeasureState(SMsrData.STMSampleRetData.SMsrField.FieldPos, Color.Yellow);
                                    //log.Warn("turn yellow!");
                                    m_OTSSamplespaceWindow.Invalidate();
                                }
                                break;
                        }
                        break;
                }
            }
            catch (Exception ex)
            {
               log.Error("RunMeasureState--The error message:" + ex.ToString()); 
            }
        }


        #endregion
        #region 设置原放大倍数与工作距离
        protected void SetRestoreWorkingDistanceAndMagnification()
        {
            //设置原放大倍数
            double m_SEMIWDistance = OTSSamplespaceWindow.m_SEMIWDistance;
            double m_SEMDMagni = OTSSamplespaceWindow.m_SEMDMagni;
            double m_PropIWDistance = OTSSamplespaceWindow.m_PropIWDistance;
            double m_PropDMagni = OTSSamplespaceWindow.m_PropDMagni;
            //m_MeasureApp.m_ProjParam.
            if (m_PropIWDistance != 0 && m_PropDMagni != 0)
            {
                m_MeasureApp.m_ProjParam.SetWorkingSampleSEMData(m_PropIWDistance, m_PropDMagni);
            }
            m_MeasureApp.m_SamplepaceWindow.SetSEMDATAMParameter(m_SEMDMagni,m_SEMIWDistance);
            m_MeasureApp.m_ProjParam.SetFliedsCount(OTSSamplespaceWindow.m_TotalFieldsCount);
        }
        #endregion

    }
}