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;
        //测量线程类
        public CMeasure m_measure = null;

        //线程执行类型 1：测量 2：获取样品孔图片
        private  MSR_RUN_TYPE doRunType = (MSR_RUN_TYPE)1;
        private int holeIdForPreview;
     
  
        NLog.Logger log ;
        #endregion
        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;
         

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

            }
            //if (m_bgWorker.IsBusy)
            //{
            //    return true;
            //}
            return false;
        }
        public bool BgWorkIsPaused()
        {
            if (m_measure.GetMsrThreadStatus().GetStatus() == OTS_MSR_THREAD_STATUS.PAUSED)
            {
                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 (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);
                DoHolePreview( );
            }
        }

   
        public void InitMeasureThread(COTSMsrPrjResultData a_ProjData)
        {
          
                m_ProjData = a_ProjData;
                m_measure.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 if (MSTMsg.STMThreadStu.iMsrStatu == otsdataconst.OTS_MSR_THREAD_STATUS.PAUSED)
                    {

                        PauseMeasure(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)
                    {
                        StopMeasure(MSTMsg);
                    }
                    else if (MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.FAILED)
                    {
                        //StopMeasure(MSTMsg);
                        log.Error("(OTSGetMreRetThread) MSTMsg.STMSampleStu.iMeasureSampleStatus = RET_MEASURE_SAMPLE_STATUS.FAILED Failed");

                    }
                    else if (MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.SUCCESSED)
                    {
                        //StopMeasure(MSTMsg);
                    }
                    else if(MSTMsg.STMSampleStu.iMsrSampleStatu == OTSDataType.OTS_MSR_SAMPLE_STATUS.PAUSED)
                    {
                        PauseMeasure(MSTMsg);
                        log.Warn("This sample measure is paused!");
                    }
                    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)
                    {
                        UpdateMeasureState(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 PauseMeasure(ST_MSTMsg SMsrData)
        {
            m_MeasureApp.SetPauseMeasureRibbonStatus();

            GetMsrRetData(ref SMsrData.STMThreadStu.SMsrCompleteData);

            m_OTSMeasureResult.RunMeasureState(SMsrData);
        }

        private void GetBSEData(ST_MSTMsg SMsrData)
        {


            m_OTSMeasureResult.RunMeasureState(SMsrData);
        }

        private void UpdateMeasureState(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<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.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_measure.Init(m_ProjData);
          

          
            return ;
        }
        public void InitHolePreview()
        {
            m_measure.Init(m_ProjData);
          
            m_measure.ProgressEvent += M_MsrThread_ProgressEvent;
           
            return ;
        }
        public void DoHolePreview()
        {
            m_measure.DoHolePreview();
        }
        // 开始样品测量
       
        //停止测量
        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()
        {
            //var hw = m_MsrThread.GetSEMController().GetHardwareInterface();
            //if (hw != null)
            //{
            //    hw.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>();
                if (!m_ProjData.GetMsredSampleList(ref MeasureCompleteSampleList))
                {
                    return false;
                }


                DateTime DTime = new DateTime();
                if (m_measure.GetMsrThreadStatus() == null)
                {
                    return false;
                }
                if (m_measure.GetMsrThreadStatus().GetStartTime() == null)
                {
                    return false;
                }
                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;
            }
        }

       
    }
}