OTS/OTSIncAMeasureApp/1-OTSMeasure/CMeasureThreadWrapper.cs

using System;
using System.ComponentModel;
using OTSModelSharp;
using OTSDataType;
using System.Collections.Generic;
using static OTSDataType.otsdataconst;
using System.Drawing;

namespace OTSMeasureApp
{
    public class CMeasureThreadWrapper 
    {
        #region 变量生成汇总
        //后台线程
        public static System.ComponentModel.BackgroundWorker m_bgWorker;
  
        OTSIncAMeasureAppForm m_MeasureApp = null;
        OTSMeasureDisplayResult m_OTSMeasureResult = null;
        //测量线程类
        CMeasure m_MsrThread = null;

        //线程执行类型 1：测量 2：获取样品孔图片
        public static int DoRunType = 1;
        public static int m_HoleID;
        public static CDomain c_DomainMessure;
        NLog.Logger log ;
        #endregion
        COTSMsrPrjResultData m_ProjData;
        #region 构造方法
        public CMeasureThreadWrapper(OTSIncAMeasureAppForm MeasureApp)
        {
            log = NLog.LogManager.GetCurrentClassLogger();
            m_ProjData = MeasureApp.m_ProjData;
            m_MeasureApp = MeasureApp;
            m_bgWorker = new BackgroundWorker();
            //设置报告更新是否可用
            m_bgWorker.WorkerReportsProgress = true;
            //设置支持取消操作是否可用
            m_bgWorker.WorkerSupportsCancellation = true;
            m_bgWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);

            m_bgWorker.WorkerSupportsCancellation = true;
           
            m_OTSMeasureResult = new OTSMeasureDisplayResult(m_MeasureApp,m_bgWorker);

            m_MsrThread = new CMeasure();
            m_MsrThread.ProgressEvent += M_MsrThread_ProgressEvent;
         

        }
        #endregion
        #region 设置线程类型
        /// <summary>
        /// 设置线程类型
        /// </summary>
        /// <param name="doRunType">线程执行类型 1：测量类型 2：获取样品孔图片类型</param>
        public void SetDoRunType(int doRunType)
        {
            DoRunType = doRunType;
        }
        #endregion
        #region 设置获取样品孔中照片所需的参数
        /// <summary>
        /// 设置获取样品孔中照片所需的参数
        /// </summary>
        /// <param name="HoleID">样品孔编号的序号</param>
        /// <param name="DomainMessure">测量区域属性对象</param>
        public void SetHoleImagePreview(int HoleID, CDomain DomainMessure)
        {
            //样品孔编号的序号
            m_HoleID = HoleID;
            //测量区域属性对象
            c_DomainMessure = DomainMessure;
        }
        #endregion
        #region 启动测量线程
        public void StartBGWorkThread()
        {
            m_bgWorker.RunWorkerAsync();
        }
        #endregion

        #region 线程是否在运行
        /// <summary>
        ///  True:  线程正在运行
        /// </summary>
        /// <returns></returns>
        public bool BGWorkThreadIsRunning()
        {

            if (m_bgWorker.IsBusy)
            {
                return true;
            }
            return false;
        }
        #endregion

        #region 判断线程挂起状态
        /// <summary>
        /// True:  线程挂起状态
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        bool WorkThreadIsPending()
        {
            return m_bgWorker.CancellationPending;
        }
        #endregion

        #region 线程挂起
        /// <summary>
        /// 线程挂起
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void SetWorkThreadPending()
        {
            m_bgWorker.CancelAsync();
            m_bgWorker = null;
        }
    
        #endregion


        #region 后台进程开始工作_DoWork
        /// <summary>
        /// 后台进程开始工作        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            if (DoRunType == (int)MSR_THREAD_RunSTATUS.RUNMEASURE)
            {
                InitMeasureThread(m_MeasureApp.m_ProjData);

                m_MsrThread.SetMsrLoopStatus(otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS);
                m_MsrThread.DoMeasure();
              
            }
            else if (DoRunType == (int)MSR_THREAD_RunSTATUS.RUNSampleHoleImage)
            {
                InitMeasureThread(m_MeasureApp.m_ProjData);

                SetMeasureThreadStatus(otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS);
                DoHolePreview(m_HoleID, c_DomainMessure);
            }
        }

   
        public void InitMeasureThread(COTSMsrPrjResultData a_ProjData)
        {
          
                m_ProjData = a_ProjData;
                m_MsrThread.Init(m_ProjData);
              
          

        }

        private void M_MsrThread_ProgressEvent(OTSModelSharp.ST_MSTMsg msg)
        {
           AddMeasureMsg(msg);
        }
        private void AddMeasureMsg(OTSModelSharp.ST_MSTMsg MSTMsg)
        {
          
            ShowCurrentFieldPointMessage(MSTMsg.STMSampleRetData.SMsrField.FieldPos);
          
            switch (MSTMsg.iMsgType)
            {
                case OTSModelSharp.ENUM_MSG_TYPE.MTHREADSTATUS:
                    if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS)
                    {

                        StartMeasure(MSTMsg);
                    }
                    else if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.STOPPED)
                    {
                        string csETime = MSTMsg.STMThreadStu.csMsrEndTime;
                        StopMeasure(MSTMsg);

                    }
                    else if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.FAILED)
                    {

                        StopMeasure(MSTMsg);
                        log.Error("(OTSGetMreRetThread)  MSTMsg.STMThreadStu.iMThreadStatus = RET_MEASURE_THREAD_STATUS.FAILED");


                    }
                    else if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.COMPLETED)
                    {

                        StopMeasure(MSTMsg);

                    }
                    else
                    {
                        log.Error("(OTSGetMreRetThread) MSTMsg.STMThreadStu.iMThreadStatus =" + MSTMsg.STMThreadStu.iMsrStatu.ToString() + "Failed");
                    }
                    break;

                case OTSModelSharp.ENUM_MSG_TYPE.MSAMPLESTATUS:
                    if (MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.INPROCESS)   // 开始测量样品
                    {
                        string csName = MSTMsg.STMSampleStu.cSampleName;
                        m_MeasureApp.SwitchMeasureSample(csName);

                        StartMsrSample(MSTMsg);

                    }
                    else if (MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.STOPPED)
                    {

                    }
                    else if (MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.FAILED)
                    {
                        log.Error("(OTSGetMreRetThread) MSTMsg.STMSampleStu.iMeasureSampleStatus = RET_MEASURE_SAMPLE_STATUS.FAILED Failed");

                    }
                    else if (MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.SUCCESSED)
                    {

                    }
                    else
                    {
                        log.Error("(OTSGetMreRetThread) MSTMsg.STMSampleStu.iMeasureSampleStatus =" + MSTMsg.STMSampleStu.iMsrSampleStatu.ToString() + "Failed");
                    }
                    break;
                case OTSModelSharp.ENUM_MSG_TYPE.MSAMPLERESULT:
                    if (MSTMsg.STMSampleRetData.iRetDataType == OTSModelSharp.MSAMPLE_RET.BSE_DATA)
                    {
                        int iHeight = MSTMsg.STMSampleRetData.BSEData.iBSEDataHeight;
                        int iWidth = MSTMsg.STMSampleRetData.BSEData.iBSEDataWidth;

                        if (iHeight > 0 && iWidth > 0)
                        {

                            GetBSEData(MSTMsg);

                        }
                        else
                        {
                            log.Error("(OTSGetMreRetThread) BSEDataHeight = " + iHeight.ToString() + "BSEDataWidth = " + iWidth.ToString() + " Failed");
                        }
                    }
                    else if (MSTMsg.STMSampleRetData.iRetDataType == OTSModelSharp.MSAMPLE_RET.FIELD_DATA)
                    {
                        GetFiledData(MSTMsg);
                    }

                    else if (MSTMsg.STMSampleRetData.iRetDataType == OTSModelSharp.MSAMPLE_RET.START_MSR_FIELD)
                    {
                        GetStartMsrField(MSTMsg);
                    }
                    else
                    {
                        log.Error("(OTSGetMreRetThread) MSTMsg.STMSampleRetData.iRetDataType =" + MSTMsg.STMSampleRetData.iRetDataType.ToString() + "Failed");
                    }
                    break;

            }
        }
        #region privte part
        private void StartMeasure(ST_MSTMsg SMsrData)
        {
            m_MeasureApp.SetStartMeasureRibbonStatus();

           GetMsrRetData(ref SMsrData.STMThreadStu.SMsrCompleteData);

            m_OTSMeasureResult.RunMeasureState(SMsrData);

        }


        private void ShowCurrentFieldPointMessage(Point currPoint)
        {
            //当前测量帧图视场坐标---------------------------------------------------------------------------------------

            Point lsp = currPoint;
            if (lsp.X != 0 || lsp.Y != 0)
            {
                string STSemCoordinate = "Current frame coordinates X:" + lsp.X.ToString() + " Y:" + lsp.Y.ToString();

                //显示当前视场 XY轴
                m_MeasureApp.ShowSemCoordvAL(STSemCoordinate);
            }
            //------------------------------------------------------------------------------------------------------------
        }

        //处理测量线程停止消息
        private void StopMeasure(ST_MSTMsg SMsrData)
        {
            m_MeasureApp.SetStopMeasureRibbonStatus();

            GetMsrRetData(ref SMsrData.STMThreadStu.SMsrCompleteData);

            m_OTSMeasureResult.RunMeasureState(SMsrData);
        }

        private void GetBSEData(ST_MSTMsg SMsrData)
        {


            m_OTSMeasureResult.RunMeasureState(SMsrData);
        }

        private void GetFiledData(ST_MSTMsg SMsrData)
        {

            this.GetSMsrUsedTime(ref SMsrData.STMSampleRetData.SFieldData.TUsedTime);

            m_OTSMeasureResult.RunMeasureState(SMsrData);
        }

        private void GetStartMsrField(ST_MSTMsg SMsrData)
        {


            m_OTSMeasureResult.RunMeasureState(SMsrData);
        }

        private void StartMsrSample(ST_MSTMsg SMsrData)
        {
            DateTime SampleMsrStartTime = new DateTime();

            m_MeasureApp.m_ProjParam.GetMsrSampleStartTime(ref SampleMsrStartTime);
            SMsrData.STMSampleStu.csSampleMsrStartTime = SampleMsrStartTime.ToString("yyyy-MM-dd HH:mm:ss");
            string csSName = "";
            List<Point> FieldList = new List<Point>();
            m_MeasureApp.m_ProjParam.GetBeforeCompleteField(ref csSName, ref FieldList);
            string csSampleName = SMsrData.STMSampleStu.cSampleName;
            if (csSName == csSampleName)
            {
                SMsrData.STMSampleStu.BCompleteFieldList = FieldList;
            }

            m_OTSMeasureResult.RunMeasureState(SMsrData);

        }

        private void GetSMsrUsedTime(ref TimeSpan MsrUsedTime)
        {
            TimeSpan UsedTime = new TimeSpan();
            if (!m_MeasureApp.m_ProjParam.GetMsrSampleUsedTime(ref UsedTime))
            {
                return;
            }

            MsrUsedTime = UsedTime;
        }
        #endregion
        public void InitMeasureSample()
        {

            m_MsrThread.Init(m_ProjData);
          

          
            return ;
        }
        public void InitHolePreview()
        {
            m_MsrThread.Init(m_ProjData);
          
            m_MsrThread.ProgressEvent += M_MsrThread_ProgressEvent;
           
            return ;
        }
        public void DoHolePreview(int m_HoleID, CDomain c_DomainMessure)
        {
            m_MsrThread.DoHolePreview(m_HoleID, c_DomainMessure);
        }
        // 开始样品测量
       
        //停止测量
        public void SetMeasureThreadStatus(otsdataconst.OTS_MSR_THREAD_STATUS ThreadStatus)
        {
            //设置测量线程状态
            m_MsrThread.SetMsrLoopStatus(ThreadStatus);
        }


        #endregion
    
        public bool ConnectSEM()
        {
           return m_MsrThread.GetSEMController().Connect();
        }
        public void DisconnectSEM()
        {
            m_MsrThread.GetSEMController().DisConnect();
        }
        public void StopXrayAcquisition()
        {
            var hw = m_MsrThread.GetSEMController().GetHardwareInterface();
            if (hw != null)
            {
                hw.StopXrayAcquisition();
            }
            
        }
        public bool IsSEMConnected()
        {
            return m_MsrThread.GetSEMController().IsConnected();
        }
        public bool GetMsrRetData(ref SMSR_COMPLETE_DATA MsrCompleteData)
        {
            try
            {
            

                List<COTSSample> MeasureCompleteSampleList = new List<COTSSample>();
                if (!m_ProjData.GetMsredSampleList(ref MeasureCompleteSampleList))
                {
                    return false;
                }


                DateTime DTime = new DateTime();
                if (m_MsrThread.GetMsrThreadStatus() == null)
                {
                    return false;
                }
                if (m_MsrThread.GetMsrThreadStatus().GetStartTime() == null)
                {
                    return false;
                }
                DTime = (DateTime)m_MsrThread.GetMsrThreadStatus().GetStartTime();
                MsrCompleteData.csMsrStartTime = DTime.ToString("yyyy-MM-dd HH:mm:ss");

                MsrCompleteData.MsrUsedTime = (TimeSpan)m_MsrThread.GetMsrThreadStatus().GetUsedTime();

                DTime = (DateTime)m_MsrThread.GetMsrThreadStatus().GetEndTime();
                MsrCompleteData.csMsrEndTime = DTime.ToString("yyyy-MM-dd HH:mm:ss");

                MsrCompleteData.iMsrCompleteSampleCount = MeasureCompleteSampleList.Count;

                MsrCompleteData.iMsrCompleteFieldCount = 0;
                MsrCompleteData.iParticleCount = 0;
                for (int i = 0; i < MsrCompleteData.iMsrCompleteSampleCount; i++)
                {
                    MsrCompleteData.iMsrCompleteFieldCount += MeasureCompleteSampleList[i].GetMsrStatus().GetCompletedFields();
                    List<CMsrResultItem> MsrRetClr = MeasureCompleteSampleList[i].GetMsrResults().GetResultItems();
                    for (int k = 0; k < MsrRetClr.Count; k++)
                    {
                        MsrCompleteData.iParticleCount += (int)MsrRetClr[k].GetNumber();
                    }
                }

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

       
    }
}