OTS/OTSIncAMeasureApp/1-OTSMeasure/Measure/3-MeasureFlow/CMeasureThreadWrapper.cs

using System;
using System.ComponentModel;
using OTSModelSharp;
using OTSDataType;
using System.Collections.Generic;
using static OTSDataType.otsdataconst;
using System.Drawing;
using OTSMeasureApp._1_OTSMeasure.Measure._3_MeasureFlow;

namespace OTSMeasureApp
{
    public class CMeasureThreadWrapper 
    {
       
        //后台线程
        public static System.ComponentModel.BackgroundWorker m_bgWorker;
  
        OTSIncAMeasureAppForm m_MeasureApp = null;
        OTSMeasureDisplayResult m_OTSMeasureResult = null;
        //测量线程类
        public CMeasure m_measure = null;

        //线程执行类型 1：测量 2：获取样品孔图片
        private  MSR_RUN_TYPE doRunType = (MSR_RUN_TYPE)1;
        private int holeIdForPreview;
     
  
        NLog.Logger log ;
     
        COTSMsrPrjResultData m_ProjData;

        public  MSR_RUN_TYPE GetDoRunType()
        {
            return doRunType;
        }

        public  void SetDoRunType(MSR_RUN_TYPE value)
        {
            doRunType = value;
        }
        #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_measure = new CMeasure();

            m_measure.ProgressEvent += M_MsrThread_ProgressEvent;
            m_measure.HolePreviewEvent += M_measure_HolePreviewEvent;

        }
        private void M_MsrThread_ProgressEvent(ST_MSTMsg MSTMsg)
        {
            ExecuteMeasureMsg(MSTMsg);
        }
        private void M_measure_HolePreviewEvent(ST_MSTMsg msg)
        {
            ExecuteHolePreviewMsg(msg);
        }

        private void ExecuteHolePreviewMsg(ST_MSTMsg MSTMsg)
        {
           

            switch (MSTMsg.iMsgType)
            {
                case ENUM_MSG_TYPE.MTHREADSTATUS:
                    if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS)
                    {
                        m_MeasureApp.SetStartMeasureRibbonStatus();
                       
                    }
                    else if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.STOPPED)
                    {
                        m_MeasureApp.SetStopMeasureRibbonStatus();
                      

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


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

                    }
                    
                   
                    break;

                case ENUM_MSG_TYPE.MSAMPLESTATUS:
                    
                    break;
                case ENUM_MSG_TYPE.MSAMPLERESULT:
                    if (MSTMsg.STMSampleRetData.iRetDataType == MSAMPLE_RET.BSE_DATA)
                    {
                        int iHeight = MSTMsg.STMSampleRetData.BSEData.iBSEDataHeight;
                        int iWidth = MSTMsg.STMSampleRetData.BSEData.iBSEDataWidth;

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

                            //获取显示BSE的图片数据
                            byte[] ImageData = MSTMsg.STMSampleRetData.BSEData.lpBSEData;
                            //图片宽度
                            int width = MSTMsg.STMSampleRetData.BSEData.iBSEDataWidth;
                            //图片高度
                            int height = MSTMsg.STMSampleRetData.BSEData.iBSEDataHeight;
                            //Field位置
                            Point fieldPos = MSTMsg.STMSampleRetData.BSEData.pos;
                            int fieldid = MSTMsg.STMSampleRetData.BSEData.fieldId;
                            //设置样品孔中BSE图像信息
                            m_MeasureApp.m_SamplepaceWindow.AddHoleBSEImageData(ImageData, width, height, fieldPos, fieldid);

                        }
                        else
                        {
                            log.Error("(OTSGetMreRetThread) BSEDataHeight = " + iHeight.ToString() + "BSEDataWidth = " + iWidth.ToString() + " Failed");
                        }
                    }
                   
                    break;

            }
        }

        public bool IsHavingNotCompleteSamples()
        {
            foreach(var s in m_measure.GetListMeasurableSamples())
            {
                if (s.GetMsrStatus().GetStatus() == OTS_MSR_SAMPLE_STATUS.PAUSED)
                {
                    return true;
                }
            
            }
            return false;
        
        }
        #endregion
 
        #region 设置获取样品孔中照片所需的参数
        /// <summary>
        /// 设置获取样品孔中照片所需的参数
        /// </summary>
        /// <param name="HoleID">样品孔编号的序号</param>
        /// <param name="DomainMessure">测量区域属性对象</param>
        public void SetHoleImagePreview(int HoleID)
        {
            //样品孔编号的序号
            holeIdForPreview = HoleID;
           
        }
        #endregion
        #region 启动测量线程
        public void StartBGWorkThread()
        {
            m_bgWorker.RunWorkerAsync();
        }
        #endregion

        #region 线程是否在运行
        /// <summary>
        ///  True:  线程正在运行
        /// </summary>
        /// <returns></returns>
        public bool BGWorkThreadIsRunning()
        {
            if (m_measure.GetMsrThreadStatus().GetStatus() == OTS_MSR_THREAD_STATUS.INPROCESS)
            {
                return true;

            }
           
            return false;
        }
        public bool BgWorkIsPaused()
        {
            if (m_measure.GetMsrThreadStatus().GetStatus() == OTS_MSR_THREAD_STATUS.PAUSED)
            {
                return true;
            }
            return false;
        }
        #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 (GetDoRunType() == MSR_RUN_TYPE.RUNMEASURE)
            {
                InitMeasureThread(m_MeasureApp.m_ProjData);

                m_measure.SetMsrLoopStatus(otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS);
                m_measure.DoMeasure();
              
            }
            else if (GetDoRunType() == MSR_RUN_TYPE.RUNSampleHoleImage)
            {
                InitMeasureThread(m_MeasureApp.m_ProjData);

                SetMeasureThreadStatus(otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS);
                m_measure.DoHolePreview();
            }
        }

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

        }

      
        private void ExecuteMeasureMsg(ST_MSTMsg MSTMsg)
        {
          
            ShowCurrentFieldPointMessage(MSTMsg.STMSampleRetData.SMsrField.FieldPos);
          
            switch (MSTMsg.iMsgType)
            {
                case ENUM_MSG_TYPE.MTHREADSTATUS:
                    if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.INPROCESS)
                    {
                        m_MeasureApp.SetStartMeasureRibbonStatus();
                       
                    }
                    else if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.STOPPED)
                    {

                        m_MeasureApp.SetStopMeasureRibbonStatus();

                        GetMsrRetData(ref MSTMsg.STMThreadStu.SMsrCompleteData);


                        m_OTSMeasureResult.MeasureStopped(MSTMsg);

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

                        m_MeasureApp.SetStopMeasureRibbonStatus();

                        GetMsrRetData(ref MSTMsg.STMThreadStu.SMsrCompleteData);


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


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

                        m_MeasureApp.SetStopMeasureRibbonStatus();

                        GetMsrRetData(ref MSTMsg.STMThreadStu.SMsrCompleteData);


                        m_OTSMeasureResult.MeasureComplete(MSTMsg);

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

                        m_MeasureApp.SetPauseMeasureRibbonStatus();

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

                case 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)
                    {
                        StopMeasure(MSTMsg);
                    }
                    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)
                    {
                        log.Info("Sample measure succeeded");
                    }
                    else if(MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.PAUSED)
                    {
                        m_MeasureApp.SetPauseMeasureRibbonStatus();
                        log.Warn("This sample measure is paused!");
                    }
                    break;
                case ENUM_MSG_TYPE.MSAMPLERESULT:
                    if (MSTMsg.STMSampleRetData.iRetDataType ==MSAMPLE_RET.BSE_DATA)
                    {
                        int iHeight = MSTMsg.STMSampleRetData.BSEData.iBSEDataHeight;
                        int iWidth = MSTMsg.STMSampleRetData.BSEData.iBSEDataWidth;

                        if (iHeight > 0 && iWidth > 0)
                        {
                            m_OTSMeasureResult.Field_BSE_DATA(MSTMsg);
                        }
                        else
                        {
                            log.Error("(OTSGetMreRetThread) BSEDataHeight = " + iHeight.ToString() + "BSEDataWidth = " + iWidth.ToString() + " Failed");
                        }
                    }
                    else if (MSTMsg.STMSampleRetData.iRetDataType == MSAMPLE_RET.FIELD_DATA)
                    {
                        this.GetSMsrUsedTime(ref MSTMsg.STMSampleRetData.SFieldData.TUsedTime);

                      
                        m_OTSMeasureResult.Field_DATA(MSTMsg);
                    }

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

            }
        }
        #region privte part
   


        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.MeasureStopped(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<PointF> FieldList = new List<PointF>();
            m_MeasureApp.m_ProjParam.GetBeforeCompleteField(ref csSName, ref FieldList);
            string csSampleName = SMsrData.STMSampleStu.cSampleName;
            if (csSName == csSampleName)
            {
                SMsrData.STMSampleStu.BCompleteFieldList = FieldList;
            }

            
            m_OTSMeasureResult.SampleStart(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_measure.Init(m_ProjData);
          

          
            return ;
        }
        public void InitHolePreview()
        {
            m_measure.Init(m_ProjData);
          
            m_measure.ProgressEvent += M_MsrThread_ProgressEvent;
           
            return ;
        }
       
      
       
        //停止测量
        public void SetMeasureThreadStatus(otsdataconst.OTS_MSR_THREAD_STATUS ThreadStatus)
        {
            //设置测量线程状态
            m_measure.SetMsrLoopStatus(ThreadStatus);
        }


        #endregion
    
        public bool ConnectSEM()
        {
           return m_measure.GetSEMController().Connect();
        }
        public void DisconnectSEM()
        {
            m_measure.GetSEMController().DisConnect();
        }
        public void StopXrayAcquisition()
        {
        
            m_measure.GetSEMController().StopXrayAcquisition();
        }
        public bool IsSEMConnected()
        {
            return m_measure.GetSEMController().IsConnected();
        }
        public bool GetMsrRetData(ref SMSR_COMPLETE_DATA MsrCompleteData)
        {
            try
            {
            

                List<COTSSample> MeasureCompleteSampleList = new List<COTSSample>();
                MeasureCompleteSampleList = m_measure.GetListMeasurableSamples();


                DateTime DTime = new DateTime();
               
                DTime = (DateTime)m_measure.GetMsrThreadStatus().GetStartTime();
                MsrCompleteData.csMsrStartTime = DTime.ToString("yyyy-MM-dd HH:mm:ss");

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

                DTime = (DateTime)m_measure.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)
            {
                log.Error(ex.Message.ToString());
                return false;
            }
        }

       
    }
}