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 OTSMeasureApp._1_OTSMeasure.Measure._3_MeasureFlow;
using static OTSMeasureApp._1_OTSMeasure.Measure._3_MeasureFlow.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 OTSPropertyWindow m_SPropertyWindows = null;

        public System.ComponentModel.BackgroundWorker m_bgWorker;


        ST_MSTMsg MeasureResultMsrData;
       
       
        #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_MeasureResultWindow;
                m_SPropertyWindows = m_MeasureApp.m_SPropertyWindows;
            
            m_OTSMeasureStatusWindow = m_MeasureApp.m_MessureStatuWindow;

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



        }

        private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            ReportProgress((ProgressState)e.ProgressPercentage);
        }
        #endregion

        #region 修改窗体控件的响应事件_ProgressChanged
        //这里就是通过响应消息，来处理界面的显示工作

        private void ReportProgress(ProgressState state)
        {
            try
            {

                if (state == ProgressState.MeasureCheckReport)
                {

                    DisMeasureResultInfo(MeasureResultMsrData);

                }
                //测量结果
                if (state == ProgressState.MeasureResult)
                {

                    if (m_OTSMeasureResultWindow == null)
                    {
                        //实例窗体
                        m_OTSMeasureResultWindow = m_MeasureApp.m_MeasureResultWindow;
                    }
                    //设置工作样品
                    m_MeasureApp.m_ProjParam.SetWorkSample(m_OTSSamplespaceWindow.GetWorkingVisualSample().GetSampleName());
                    //获取工作样品信息
                    COTSSample WSample = m_MeasureApp.m_ProjParam.GetWorkSample();
                    CMsrResultItems MsrResults = WSample.GetMsrResults();
                    //获取结果文件 颗粒列表信息
                    List<CMsrResultItem> cMsrResultItemClrList = MsrResults.GetResultItems();

                    //设置测量状态数据列表

                    m_OTSMeasureResultWindow.SetMeasureListInfo(cMsrResultItemClrList);

                }

            }
            catch (Exception ex)
            {
                log.Error(ex.ToString());
            }

        }

        #endregion





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

        #region 显示BSE图片
        public void OTSMeasureStatusWindowFun(int width, int height, byte[] ImageData, OTSIncAMeasureAppForm m_MeasureApps)
        {
            //设置图像数据与状态
            OTSMeasureStatusWindow.bfResult = true;
            m_MeasureApps.m_MessureStatuWindow.originalBseData = ImageData;
            //获取灰度图数据
            double[] dGrayLevelData = new double[255];
            dGrayLevelData = 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.picBox.Show();
  
            //显示BSE图
            m_MeasureApps.m_MessureStatuWindow.ShowImage(width, height, ImageData);
        }
        public double[] GetStaticGaryData(byte[] Imagedata, double[] GrayLevelData)
        {
            try
            {
                //获得下标每一点的灰度值，并在数组里加一
                for (int i = 0; i < Imagedata.Length; i++)
                {
                    byte graylevel = Imagedata[i];
                    if (graylevel > 0 && graylevel < 255)
                    {
                        GrayLevelData[graylevel] += 1;
                    }
                }
                return GrayLevelData;
            }
            catch (Exception ex)
            {
                log.Error(ex.ToString());
                return null;
            }
        }
        #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.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

       

        public void MeasureComplete(ST_MSTMsg SMsrData)
        {


            string inprocessEndTime = SMsrData.STMThreadStu.csMsrEndTime;
           
           
            //获取需显示的grid信息
            var sample = m_MeasureApp.m_ProjParam.GetWorkSample();
            var stype = m_MeasureApp.m_ProjParam.GetDefaultParam().GetSysType();
            OTSSampleVisualPropertyInfo MeasureInfo = new OTSSampleVisualPropertyInfo(sample, stype);
            m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
            SetMeasureResultInfo(SMsrData);
            MeasureResultMsrData = SMsrData;

            m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport);
        }





            #region 测量方法
            //运行测量状态方法
        //public void UpdateMeasureState_samplespace_propertyGrid(ST_MSTMsg SMsrData)
        //{
           
                
              
        //        //测量状态:开始状态、完成状态(测量停止、测量失败、测量完成)
        //        OTS_MSR_THREAD_STATUS msrStatus = SMsrData.STMThreadStu.iMsrStatu;

               


        //        switch (SMsrData.iMsgType)
        //        {
        //            //测量线程状态
        //            case ENUM_MSG_TYPE.MTHREADSTATUS:
        //                switch (msrStatus)
        //                {
        //                    //测量状态在进行中-测量开始
        //                    case OTS_MSR_THREAD_STATUS.INPROCESS:
                               
        //                        break;
        //                    //测量状态已完成
        //                    case OTS_MSR_THREAD_STATUS.COMPLETED:
        //                        //当前线程执行类型 1：测量
        //                        MeasureComplete(SMsrData);




        //                        break;
        //                    //测量状态已失败
        //                    case OTS_MSR_THREAD_STATUS.FAILED:
        //                        //当前线程执行类型 1：测量
        //                        MeasureFailed(SMsrData);
                                    
                               
        //                        break;
        //                    //测量状态已停止
        //                    case OTS_MSR_THREAD_STATUS.STOPPED:
        //                        //当前线程执行类型 1：测量
        //                        MeasureStopped(SMsrData);
                                
                               
                          

                             
        //                        break;
        //                }
        //                break;
        //            //测量结果
        //            case ENUM_MSG_TYPE.MSAMPLESTATUS:
        //                //获取测量状态样品信息
        //                OTS_MSR_SAMPLE_STATUS msrSampleStatu = SMsrData.STMSampleStu.iMsrSampleStatu;
        //                switch (msrSampleStatu)
        //                {
        //                    case OTS_MSR_SAMPLE_STATUS.INPROCESS:
        //                        //当前线程执行类型 1：测量
        //                        SampleStart(SMsrData);
                               
        //                        break;
        //                }
        //                break;
        //            case ENUM_MSG_TYPE.MSAMPLERESULT:
        //                //获取测量状态的Field与BSE信息
        //                MSAMPLE_RET retDataType = SMsrData.STMSampleRetData.iRetDataType;

        //                //判断测量状态提供Field与BSE信息
        //                switch (retDataType)
        //                {
        //                    case MSAMPLE_RET.BSE_DATA:

        //                        Field_BSE_DATA(SMsrData);
                               
                                
                                   
                                
        //                        break;
        //                    case MSAMPLE_RET.FIELD_DATA:
        //                        //当前线程执行类型 1：测量
        //                        Field_DATA(SMsrData);
        //                        //设置测量当前用时
                               

                               
        //                        break;
        //                    case MSAMPLE_RET.START_MSR_FIELD:
        //                        //当前线程执行类型 1：测量
        //                        Field_START_MSR(SMsrData);
                                   
                                
        //                        break;
        //                }
        //                break;
        //        }
           
        //}

        public void Field_START_MSR(ST_MSTMsg SMsrData)
        {
            var sam1 = m_MeasureApp.m_SamplepaceWindow.GetWorkingVisualSample();
            m_MeasureApp.m_SamplepaceWindow.ChangeDoneMeasureState(sam1, SMsrData.STMSampleRetData.SMsrField.FieldPos, Color.Yellow);

            m_MeasureApp.m_SamplepaceWindow.Invalidate();
        }

        public void Field_DATA(ST_MSTMsg SMsrData)
        {
            
                
            m_OTSMeasureResultWindow.SetMeasureTime(SMsrData.STMSampleRetData.SFieldData.TUsedTime);
            
            //---------update the progress bar测量状态进度窗口
            var FieldData =SMsrData.STMSampleRetData.SFieldData;
            //样品测量中的总帧图数
            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);
            }
            //-----------
            var sam = m_MeasureApp.m_SamplepaceWindow.GetWorkingVisualSample();
            m_MeasureApp.m_SamplepaceWindow.ChangeDoneMeasureState(sam, SMsrData.STMSampleRetData.SFieldData.FieldPos, Color.Green);
            m_MeasureApp.m_SamplepaceWindow.Invalidate();
        }

        public void Field_BSE_DATA(ST_MSTMsg SMsrData)
        {
            //获取显示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.picBox.Visible)
            {
                m_MeasureApp.m_MessureStatuWindow.picBox.Visible = true;
            }
            //调用测量状态TAB中窗体 显示BSE图片
            OTSMeasureStatusWindowFun(width, height, ImageData, m_MeasureApp);
        }

        public void SampleStart(ST_MSTMsg SMsrData)
        {
            //获取样品名称
            string sampleName = SMsrData.STMSampleStu.cSampleName;
            //样品测量开始时间
            string csSampleMsrStartTime = SMsrData.STMSampleStu.csSampleMsrStartTime;
            //设置样品名称
            
                if (sampleName != "")
                {
                    
                        m_MeasureApp.m_SamplepaceWindow.SetSampleOrder(sampleName);


                        if (m_MeasureApp.GetRunType() == MSR_RUN_TYPE.RUNMEASURE)
                        {
                            m_OTSMeasureResultWindow.SetSampleName(sampleName);
                        }
                        m_MeasureApp.m_SamplepaceWindow.Invalidate();
                   
                    //设置开始时间
                  
                m_OTSMeasureResultWindow.SetStartTime(csSampleMsrStartTime);
            }
            
            //切换样品
            m_MeasureApp.SwitchWSample(sampleName);
            //设置样品名称
            m_OTSMeasureResultWindow.SetSampleName(sampleName);
        }

        public void MeasureStopped(ST_MSTMsg SMsrData)
        {
            string stopEndTime = SMsrData.STMThreadStu.csMsrEndTime;
            //打开测量结果窗口
            SetMeasureResultInfo(SMsrData);
            MeasureResultMsrData = SMsrData;
            m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport);
            //测量停止，更新Grid显示的测量信息
            //获取需显示的grid信息
            var sample = m_MeasureApp.m_ProjParam.GetWorkSample();
            var stype = m_MeasureApp.m_ProjParam.GetDefaultParam().GetSysType();
            OTSSampleVisualPropertyInfo MeasureInfo = new OTSSampleVisualPropertyInfo(sample, stype);
            m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
        }

        public void MeasureFailed(ST_MSTMsg SMsrData)
        {
            string failedEndTime = SMsrData.STMThreadStu.csMsrEndTime;
            SetMeasureResultInfo(SMsrData);
            MeasureResultMsrData = SMsrData;
           m_bgWorker.ReportProgress((int)ProgressState.MeasureCheckReport);



            //测量失败，更新Grid显示的测量信息
            //获取需显示的grid信息
            var sample = m_MeasureApp.m_ProjParam.GetWorkSample();
            var stype = m_MeasureApp.m_ProjParam.GetDefaultParam().GetSysType();
            OTSSampleVisualPropertyInfo MeasureInfo = new OTSSampleVisualPropertyInfo(sample, stype);
            m_MeasureApp.m_SPropertyWindows.DisplaySampleMeasureInfo(MeasureInfo);
        }

        #endregion


    }
}