OTS/OTSIncAMeasureApp/0-OTSModel/OTSDataType/COTSSample.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static OTSDataType.otsdataconst;

using OTSModelSharp;
using System.Xml;
using OTSModelSharp.ResourceManage;
using static OTSModelSharp.ResourceManage.ResourceID;

namespace OTSDataType
{




    public enum OTS_ITEM_TYPES
    {
        INVALID = -1,

        BOOL = 0,
        INT = 1,
        DOUBLE = 2,
        STRING = 3,
        COMBO = 4,
        TIME = 5,
        TIME_SPAN = 6,
        FILE_LIST = 7

    }



    public class COTSSample : ISlo
    {
        const string NOT_APPLIED = "N/A";
        private string m_strName;
        private string m_strHoleName;
        private bool m_bParamLock;
     
        private bool m_bSwitch;
    
        private CSampleParam m_poMsrParams;
        private CDomain m_poMsrArea;
        private CSEMDataMsr m_poSEMDataMsr;
        private CMsrSampleStatus m_Status;
        private CMsrDisplayResults m_poMsrResults;
        private MEMBRANE_TYPE m_membraneType;
        private List<COTSFieldData> m_listFieldData;
        private List<CPropItemGrp> m_listPropItemGrp;
        public COTSSample()
        {
            // initialization
            Init();
        }
        void Init()
        {
            m_strName = "";
            m_strHoleName = "";
            m_bParamLock = false;
            m_bSwitch = true;
            //m_bSysSTDSwitch = true;
            m_poMsrParams = new CSampleParam();
            m_poMsrArea = new CDomain();
            m_poSEMDataMsr = new CSEMDataMsr();
            m_Status = new CMsrSampleStatus();
            m_poMsrResults = new CMsrDisplayResults();
            m_membraneType = MEMBRANE_TYPE.Abrasive;
            m_listFieldData = new List<COTSFieldData>();
            m_listPropItemGrp = new List<CPropItemGrp>();
        }
        //设置工作样品的属性值
        public bool SetParamVal(OTS_SAMPLE_PROP_GRID_ITEMS ItemId, OTS_ITEM_TYPES ValType, object objVal)
        {


            bool bSetFalg = false;

            switch (ValType)
            {
                case OTS_ITEM_TYPES.BOOL:
                    {
                        //设置工作样品值失败
                        if (!SetPropboolData(ItemId, (bool)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.INT:
                    {
                        //设置工作样品值失败
                        if (!SetPropIntData(ItemId, (int)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;

                case OTS_ITEM_TYPES.DOUBLE:
                    {
                        //设置工作样品值失败
                        if (!SetPropdoubleData(ItemId, Convert.ToDouble(objVal)))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;
                case OTS_ITEM_TYPES.STRING:
                    {

                        //设置工作样品值失败
                        if (!SetPropStringData(ItemId, (string)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;
                case OTS_ITEM_TYPES.COMBO:
                    {
                        //设置工作样品值失败
                        if (!SetPropComboData(ItemId, (int)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.TIME:
                    {
                        //设置工作样品值失败
                        if (!SetPropTimeData(ItemId, (DateTime)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.TIME_SPAN:
                    {
                        //设置工作样品值失败
                        if (!SetPropTimeSpanData(ItemId, (TimeSpan)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;
                case OTS_ITEM_TYPES.FILE_LIST:
                    {
                        //设置工作样品值失败
                        if (!SetPropFileListData(ItemId, (string)objVal))
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;
                default:

                    bSetFalg = false;
                    break;
            }


            return bSetFalg;
        }
        public bool SetPropboolData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, bool a_bValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.SWITCH:
                    {
                        m_bSwitch = a_bValue;
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.SYS_STD_SWITCH:
                    {
                        m_poMsrParams.SetSysSTDSwitch(a_bValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.USING_XRAY:
                    {
                        //int m_UsingXray = a_bValue ? 1 : 0;
                        
                        m_poMsrParams.GetXRayParam().SetUsingXray(a_bValue);
                    }
                    break;
                default:
                    {
                        // something wrong, return false
                        return false;
                    }


            }

            // failed, return false
            return true;
        }

        public CDomain GetMsrArea() { return m_poMsrArea; }
        public bool SetPropdoubleData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, double a_dValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION:
                    {
                        // value validation
                        if (a_dValue < MAGNIFICATION_MIN || a_dValue > MAGNIFICATION_MAX)
                        {
                            return false;
                        }
                        m_poSEMDataMsr.SetMagnification(a_dValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE:
                    {
                        if (a_dValue < RESOLUTION_MIN || a_dValue > RESOLUTION_MAX)
                        {
                            return false;
                        }

                    

                        int nScanFieldSize=0;
                        int nScanFieldHeight=0;
                          CalculateScanFieldSize(a_dValue,ref nScanFieldSize,ref nScanFieldHeight);

                        m_poSEMDataMsr.SetScanFieldWidth(nScanFieldSize);
                        m_poSEMDataMsr.SetScanFieldHeight(nScanFieldHeight);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN:
                    {
                        if (PARTICLE_AREA_MIN > a_dValue || a_dValue > PARTICLE_AREA_MAX)
                        {
                            return false;
                        }

                        CDoubleRange oIncArea = new CDoubleRange();
                        double start = m_poMsrParams.GetImageProcessParam().GetIncAreaRange().GetStart();
                        double end = m_poMsrParams.GetImageProcessParam().GetIncAreaRange().GetEnd();
                        oIncArea.SetStart(a_dValue);
                        oIncArea.SetEnd(end);
                        m_poMsrParams.GetImageProcessParam().SetIncAreaRange(oIncArea);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX:
                    {
                        if (PARTICLE_AREA_MIN > a_dValue || a_dValue > PARTICLE_AREA_MAX)
                        {
                            return false;
                        }
                        CDoubleRange oIncArea = new CDoubleRange();
                        double start = m_poMsrParams.GetImageProcessParam().GetIncAreaRange().GetStart();
                        double end = m_poMsrParams.GetImageProcessParam().GetIncAreaRange().GetEnd();
                        oIncArea.SetStart(start);
                        oIncArea.SetEnd(a_dValue);
                        m_poMsrParams.GetImageProcessParam().SetIncAreaRange(oIncArea);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_QUANTIFY_MINSIZE:
                    {
                        if (0 >= a_dValue)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetQuantifyMinSize(a_dValue);
                    }
                    break;

                // read only property, tread as default. 
                case OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.RATIO:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE_AREA:
                default:
                    {
                        // something wrong, return false
                        return false;
                    }
                    //break;

            }

            // ok, return true
            return true;
        }
        // duplication 
        public void Duplicate(COTSSample a_oSource)
        {
            // copy data over
            m_strName = a_oSource.m_strName;
            m_strHoleName = a_oSource.m_strHoleName;
            m_bParamLock = a_oSource.m_bParamLock;
            m_bSwitch = a_oSource.m_bSwitch;
            m_poMsrParams = new CSampleParam(a_oSource.m_poMsrParams);
            m_poMsrArea = new CDomain(a_oSource.m_poMsrArea);
            m_poSEMDataMsr = new CSEMDataMsr(a_oSource.m_poSEMDataMsr);
            m_Status = new CMsrSampleStatus(a_oSource.m_Status);
            m_poMsrResults = new CMsrDisplayResults(a_oSource.m_poMsrResults);
            m_membraneType = a_oSource.m_membraneType;
        }
        // calculate scan field size
        public void CalculateScanFieldSize(double a_dPixelSize,ref int scanFieldWidth,ref int scanFieldHeight)
        {
    
                // get image size
                OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
                long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
                int nImagewidth = RESOLUTION_VALUE[nResulotionId].Width;
                int nHeight = RESOLUTION_VALUE[nResulotionId].Height;

                // calculate scan field size
                scanFieldWidth = (int)((a_dPixelSize * (double)nImagewidth) + 0.5);
                scanFieldHeight= (int)((a_dPixelSize * (double)nHeight) + 0.5);
           
        }
        public bool GetBSESize(out int a_nWidth, out int a_nHeight)
        {
            // scan parameters
            CSampleParam pMsrParam = GetMsrParams();

            COTSImgScanPrm pImgScanParam = pMsrParam.GetImageScanParam();


            // get image size
            OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = pImgScanParam.GetImageResulotion();
            int nResulotionId = RESOLUTION_ID_FIRST_TIE + (int)nImageSizeId;
            Size sizePixelImage = RESOLUTION_VALUE[nResulotionId];

            // get scan field size
            a_nWidth = sizePixelImage.Width;
            a_nHeight = sizePixelImage.Height;

            return true;
        }
        // name
        public string GetName() { return m_strName; }
        public void SetName(string a_strName) { m_strName = a_strName; }

        // sample hole
        public string GetSampleHoleName() { return m_strHoleName; }
        public void SetSampleHoleName(string a_strHoleName) { m_strHoleName = a_strHoleName; }

        // param modify lock
        public bool GetParamLock() { return m_bParamLock; }
        public void SetParamLock(bool a_bParamLock) { m_bParamLock = a_bParamLock; }

        // switch
        public bool GetSwitch() { return m_bSwitch; }
        public void SetSwitch(bool a_bSwitch) { m_bSwitch = a_bSwitch; }

        // measurement parameter 
        public CSampleParam GetMsrParams() { return m_poMsrParams; }
        public void SetMsrParams(CSampleParam a_poMsrParams)
        {
            m_poMsrParams = a_poMsrParams;
        }

        // measurement area

        public void SetMsrArea(CDomain a_poMsrArea)
        {
            m_poMsrArea = a_poMsrArea;
        }

        // SEM data (measurement)
        public CSEMDataMsr GetSEMDataMsr() { return m_poSEMDataMsr; }
        public void SetSEMDataMsr(CSEMDataMsr a_poSEMDataMsr)
        {
            m_poSEMDataMsr = a_poSEMDataMsr;
        }

        // measure status
        public CMsrSampleStatus GetMsrStatus() { return m_Status; }
        public void SetMsrStatus(CMsrSampleStatus a_poMsrStatus)
        {
            m_Status = a_poMsrStatus;
        }
        // fields
        public List<COTSFieldData> GetFieldsData() { return m_listFieldData; }
        public void SetFieldsData(List<COTSFieldData> a_listFieldData)
        {
            m_listFieldData = a_listFieldData;
            for (int i = 0; i < m_listFieldData.Count; i++)
            {
                m_listFieldData[i].SetId(i);
            }
            var mySemdata = GetSEMDataMsr();

            mySemdata.SetTotalFields(m_listFieldData.Count);
        }
       
        public void AddFieldData(PointF centerPoint )

        {
            var pixelsize = CalculatePixelSize();
            var newfld = new COTSFieldData(centerPoint, pixelsize);

            int nNewFieldId;
            nNewFieldId =GetIdForANewField();
            newfld.SetId(nNewFieldId);
            

           
            m_listFieldData.Add(newfld);

            var mySemdata = GetSEMDataMsr();

            mySemdata.SetTotalFields(m_listFieldData.Count);
          

        }
        public void ClearFields()
        {
            m_listFieldData.Clear();
        }
        public int GetIdForANewField()
        {
            List<COTSFieldData> listFieldData = GetFieldsData();
            // new field id
            int nNewFieldId = listFieldData.Count;

            do
            {
                bool iffound = false;
                COTSFieldData cOTSFieldData;
                for (int i = 0; i < listFieldData.Count; i++)
                {
                    cOTSFieldData = listFieldData[i];
                    if (cOTSFieldData.GetId() == nNewFieldId)
                    {
                        iffound = true;
                    }
                }

                if (iffound == true)
                {
                    ++nNewFieldId;
                }
                else
                {
                    break;
                }

            } while (true);



            return nNewFieldId;
        }
        // measure results
        public CMsrDisplayResults GetMsrResults() { return m_poMsrResults; }
        public void SetMsrResults(CMsrDisplayResults a_poMsrResults)
        {
            m_poMsrResults = a_poMsrResults;
        }

        // has measure results test
        public bool HasMeasureResult()
        {
            // result items is not empty
            bool bHasResult = (m_poMsrResults.GetResultItems().Count != 0);
            return bHasResult;
        }
        public MEMBRANE_TYPE GetMembraneType() { return m_membraneType; }
        public void SetMembraneType(MEMBRANE_TYPE val) { m_membraneType = val; }

        // BOOL data (1)
        public bool GetPropBOOLData(int a_nId, out bool a_bValue)
        {
            switch (a_nId)
            {
                case (int)OTS_SAMPLE_PROP_GRID_ITEMS.SWITCH:
                    {
                        a_bValue = m_bSwitch;
                    }
                    break;
                case (int)OTS_SAMPLE_PROP_GRID_ITEMS.SYS_STD_SWITCH:
                    {
                        a_bValue = m_poMsrParams.GetSysSTDSwitch();
                    }
                    break;
                case (int)OTS_SAMPLE_PROP_GRID_ITEMS.USING_XRAY:
                    {
                        a_bValue = m_poMsrParams.GetXRayParam().GetUsingXray() ;
                    }
                    break;
                default:
                    {
                        a_bValue = false;
                        // something wrong, return FALSE
                        return false;
                    }
                    break;

            }

            // ok, return TRUE
            return true;
        }
      
        public bool GetPropIntData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, out int a_nValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_PARTICLE:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetStopParamParticles();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_FIELD:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetStopParamFields();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_TIME:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetStopParamMeasTime();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_AREA:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetStopParamArea();
                    }
                    break;


                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN:
                    {
                        a_nValue = m_poMsrParams.GetImageProcessParam().GetBGGray().GetStart();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX:
                    {
                        a_nValue = m_poMsrParams.GetImageProcessParam().GetBGGray().GetEnd();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN:
                    {
                        a_nValue = m_poMsrParams.GetImageProcessParam().GetParticleGray().GetStart();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX:
                    {
                        a_nValue = m_poMsrParams.GetImageProcessParam().GetParticleGray().GetEnd();
                    }
                    break;

          
                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_COUNTS:
                    {
                        a_nValue = m_poMsrParams.GetXRayParam().GetAnalyExpCount();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                    {
                        a_nValue = (int)m_poMsrParams.GetXRayParam().GetMidAnalyAQTime();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS:
                    {
                        a_nValue = m_poSEMDataMsr.GetTotalFields();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.COMPLETED_FIELDS:
                    {
                        a_nValue = m_Status.GetCompletedFields();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE:
                    {
                        a_nValue = (int)m_poMsrResults.GetTotalParticleNumber();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_AREAPERCENTAGE:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetFieldAreaPercentage();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_LARGEPARTICLES:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetFieldLargeParticleNum();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_LARGEPARTICLESPERCENTAGE:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetFieldLargeParticlesPercentage();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_SMALLPARTICLES:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetFieldSmallParticleNum();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_SMALLPARTICLESPERCENTAGE:
                    {
                        a_nValue = m_poMsrParams.GetImageScanParam().GetFieldSmallParticlesPercentage();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_FASTTIME:
                    {
                        a_nValue = m_poMsrParams.GetXRayParam().GetFastXrayTime();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.XrayLimit:
                    {
                        a_nValue = m_poMsrParams.GetXRayParam().GetXrayLimit();
                    }
                    break;
                default:
                    {
                        // something wrong, return false
                        a_nValue = -1;
                        return false;
                    }


            }

            // ok, return true
            return true;
        }

        public bool SetPropFileListData(OTS_SAMPLE_PROP_GRID_ITEMS itemId, string objVal)
        {
            throw new NotImplementedException();
        }

        public bool SetPropIntData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, int a_nValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_PARTICLE:
                    {
                        // value validation
                        if (STOP_PARAM_PARTICLE_MIN >= a_nValue || a_nValue > STOP_PARAM_PARTICLE_MAX)
                        {
                            return false;
                        }

                        if (m_poMsrParams.GetImageScanParam().GetStopParamParticles() != a_nValue)
                        {
                            m_poMsrParams.GetImageScanParam().SetStopParamParticles(a_nValue);
                            m_Status.SetStatus(OTS_MSR_SAMPLE_STATUS.UNMEASURED);
                        }

                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_FIELD:
                    {
                        if (STOP_PARAM_FIELD_MIN >= a_nValue || a_nValue > STOP_PARAM_FIELD_MAX)
                        {
                            return false;
                        }

                        if (m_poMsrParams.GetImageScanParam().GetStopParamFields() != a_nValue)
                        {
                            m_poMsrParams.GetImageScanParam().SetStopParamFields(a_nValue);
                            m_Status.SetStatus(OTS_MSR_SAMPLE_STATUS.UNMEASURED);
                        }

                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_TIME:
                    {
                        if (STOP_PARAM_MSR_TINE_MIN >= a_nValue || a_nValue > STOP_PARAM_MSR_TINE_MAX)
                        {
                            return false;
                        }

                        if (m_poMsrParams.GetImageScanParam().GetStopParamMeasTime() != a_nValue)
                        {
                            m_poMsrParams.GetImageScanParam().SetStopParamMeasTime(a_nValue);
                            m_Status.SetStatus(OTS_MSR_SAMPLE_STATUS.UNMEASURED);
                        }

                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_AREA:
                    {
                        if (STOP_PARAM_MSR_TINE_MIN >= a_nValue || a_nValue > STOP_PARAM_FIELD_MAX)
                        {
                            return false;
                        }

                        if (m_poMsrParams.GetImageScanParam().GetStopParamArea() != a_nValue)
                        {
                            m_poMsrParams.GetImageScanParam().SetStopParamArea(a_nValue);
                            m_Status.SetStatus(OTS_MSR_SAMPLE_STATUS.UNMEASURED);
                        }

                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN:
                    {
                        if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
                        {
                            return false;
                        }

                        if (m_poMsrParams == null)
                        {
                            return false;
                        }

                        COTSImageProcParam pImageProcessParam = m_poMsrParams.GetImageProcessParam();
                        if (pImageProcessParam == null)
                        {
                            return false;
                        }

                        CIntRange oBGGray = m_poMsrParams.GetImageProcessParam().GetBGGray();
                        oBGGray.SetStart(a_nValue);
                        m_poMsrParams.GetImageProcessParam().SetBGGray(oBGGray);

                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX:
                    {
                        if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
                        {
                            return false;
                        }

                        CIntRange oBGGray = m_poMsrParams.GetImageProcessParam().GetBGGray();
                        oBGGray.SetEnd(a_nValue);
                        m_poMsrParams.GetImageProcessParam().SetBGGray(oBGGray);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN:
                    {
                        if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
                        {
                            return false;
                        }
                        CIntRange oParticleGray = m_poMsrParams.GetImageProcessParam().GetParticleGray();
                        oParticleGray.SetStart(a_nValue);
                        m_poMsrParams.GetImageProcessParam().SetParticleGray(oParticleGray);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX:
                    {
                        if (GRAY_LEVEL_MIN > a_nValue || a_nValue > GRAY_LEVEL_MAX)
                        {
                            return false;
                        }
                        CIntRange oParticleGray = m_poMsrParams.GetImageProcessParam().GetParticleGray();
                        oParticleGray.SetEnd(a_nValue);
                        m_poMsrParams.GetImageProcessParam().SetParticleGray(oParticleGray);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.LOW_COUNTS:
                    {
                        if (COUNTS_MIN > a_nValue)
                        {
                            return false;
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_COUNTS:
                    {
                        if (COUNTS_MIN > a_nValue)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetAnalyExpCount(a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                    {
                        if (0 >= a_nValue)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetMidAnalyAQTime(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_AREAPERCENTAGE:
                    {

                        m_poMsrParams.GetImageScanParam().SetFieldAreaPercentage(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_LARGEPARTICLES:
                    {

                        m_poMsrParams.GetImageScanParam().SetFieldLargeParticleNum(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_LARGEPARTICLESPERCENTAGE:
                    {

                        m_poMsrParams.GetImageScanParam().SetFieldLargeParticlePercentage(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_SMALLPARTICLES:
                    {
                        if (0 >= a_nValue)
                        {
                            return false;
                        }
                        m_poMsrParams.GetImageScanParam().SetFieldSmallParticleNum(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELDSTOP_SMALLPARTICLESPERCENTAGE:
                    {
                        if ((0 >= a_nValue) || (100 < a_nValue))
                        {
                            return false;
                        }
                        m_poMsrParams.GetImageScanParam().SetFieldSmallParticlePercentage(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_FASTTIME:
                    {
                        if (0 >= a_nValue)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetFastXrayTime(a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.XrayLimit:
                    {
                        if (0 >= a_nValue)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetXrayLimit(a_nValue);
                    }
                    break;
                // read only properties, treat same as default
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.COMPLETED_FIELDS:
                
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE:
                
                default:
                    {
                        // something wrong, return false
                        return false;
                    }


            }

            // ok, return true
            return true;
        }

        public bool SetPropItemGrpsForIncA()
        {
            if (m_listPropItemGrp != null)
            {
                if (m_listPropItemGrp.Count > 0)
                {
                    m_listPropItemGrp.Clear();
                }
            }
            // property items group
            OTS_SAMPLE_PROP_GRID_ITEM_GROUPS a_nId = 0;
            for (int i = (int)OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MIN; i <= (int)OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MAX; i++)
            {
               
                // items list
                List<CPropItem> a_listPropItems = new List<CPropItem>();
                a_nId = (OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)i;
                if (m_poMsrParams.m_runmode == RunMode.PlainMode)
                {
                    if (a_nId != OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.GENERAL)
                    {
                        break;//if it's plainmode then only display the general parameter section.
                    }

                }

               

                CPropItemGrp poPropItemGrp = new CPropItemGrp();
                // property items group name
                string strGrpName = string.Empty;
                strGrpName = ResourceData.GetSourceTitleString((OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)a_nId);
                if (strGrpName == "")
                {
                    return false;
                }
                // group name and id
                poPropItemGrp.SetName(strGrpName);
                poPropItemGrp.SetGroupId(a_nId);
                // set group items list
                OTS_SAMPLE_PROP_GRID_ITEMS nItemId;
                CPropItem poPropItem;
                bool bShow = true;
                //分组编号
                int modelResource = ResourceID.GrpGeneral;
                switch (a_nId)
                {
                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.GENERAL:
                        {
                            modelResource = ResourceID.GrpGeneral;
                            // name
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // hole
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_HOLE_NAME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // switch
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SWITCH;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.BOOL, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // system STD
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SYS_STD_SWITCH;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.BOOL, false, bShow);
                            a_listPropItems.Add(poPropItem);

                        

                            // STD file name
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.FILE_LIST, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // Steel technology
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STEEL_TECHNOLOGY;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.IMAGESCAN:
                        {
                            modelResource = ResourceID.GrpImageScan;
                            // start mode
                            COTSImgScanPrm pScanParam = m_poMsrParams.GetImageScanParam();
                            
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                                a_listPropItems.Add(poPropItem);
                           
                            //// stop mode
                            
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, bShow);
                                a_listPropItems.Add(poPropItem);

                            //// stop parameter
                            

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_PARTICLE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);

                            // field
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_FIELD;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);

                            // used time
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_TIME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);

                            // area

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_AREA;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, bShow);
                            a_listPropItems.Add(poPropItem);

                            // scan speed

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // image resolution

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.IMAGE_PROCESS:
                        {
                            modelResource = ResourceID.GrpImageProcess;
                            COTSImageProcParam pProcParam = m_poMsrParams.GetImageProcessParam();

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.BGREMOVE_TYPE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            switch (m_poMsrParams.GetImageProcessParam().GetBGRemoveType())
                            {
                                case OTS_BGREMOVE_TYPE.AUTO:
                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.AUTOBGREMOVE_TYPE;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                                    a_listPropItems.Add(poPropItem);
                                    // particle area min
                                   
                                        poPropItem = new CPropItem();
                                        nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN;
                                        poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                        a_listPropItems.Add(poPropItem);
                                   
                                    // particle area max
                                   
                                        poPropItem = new CPropItem();
                                        nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX;
                                        poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                        a_listPropItems.Add(poPropItem);
                                   
                                    break;
                                case OTS_BGREMOVE_TYPE.MANUAL:
                                   
                                   
                                    // BG gray level min
                                    
                                        poPropItem = new CPropItem();
                                        nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN;
                                        poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                        a_listPropItems.Add(poPropItem);
                                   
                                    // BG gray level max
                                   
                                        poPropItem = new CPropItem();
                                        nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX;
                                        poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                        a_listPropItems.Add(poPropItem);
                                    //---------------------------------------
                                    // particle gray level min

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    // particle gray level max

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                    a_listPropItems.Add(poPropItem);
                                    //----------------------------------------

                                    // particle area min

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    // particle area max

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                            

                                    break;

                            }
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.XRAY:
                        {
                            modelResource = ResourceID.GrpXray;
                            COTSXRayParam pXrayParam = m_poMsrParams.GetXRayParam();

                         

                            // UsingXray
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.USING_XRAY;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.BOOL, false, bShow);
                            a_listPropItems.Add(poPropItem);

                         
                            //quantify size
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_QUANTIFY_MINSIZE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                            a_listPropItems.Add(poPropItem);
                            // scan mode 

                            poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                                a_listPropItems.Add(poPropItem);

                            // analysis 

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION;//big particle AQTime
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);
                            //fast xray time.
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_FASTTIME;//small particle AQTime
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);
                            // analysis counts 

                            poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_COUNTS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                a_listPropItems.Add(poPropItem);

                            // XrayLimit 
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.XrayLimit;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);

                        }
                        break;
                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.SEM:
                        {
                            modelResource = ResourceID.GrpSEMParameter;
                            // does SEM data (measure) set?
                            CSEMDataMsr m_TempSEMDataMsr = new CSEMDataMsr();
                            if ((m_poSEMDataMsr.GetScanFieldSize100() == m_TempSEMDataMsr.GetScanFieldSize100())
                                && (m_poSEMDataMsr.GetTotalFields() == m_TempSEMDataMsr.GetTotalFields())
                                && (m_poSEMDataMsr.GetWorkingDistance() == m_TempSEMDataMsr.GetWorkingDistance())
                                && (m_poSEMDataMsr.GetScanFieldSize() == m_TempSEMDataMsr.GetScanFieldSize()))
                            {
                                // magnification
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // pixel size
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // working distance
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total field
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total area
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                            else
                            {
                                // magnification
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, true);
                                a_listPropItems.Add(poPropItem);

                                // pixel size
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, true);
                                a_listPropItems.Add(poPropItem);

                                // working distance
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total field
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total area
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MEASURE_STATUS:
                        {
                            modelResource = ResourceID.GrpMeasureState;
                            // measure status 
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_STATAU;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                            a_listPropItems.Add(poPropItem);

                            // has measure result?
                            if (HasMeasureResult())
                            {
                                // start time 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.START_TIME;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.TIME, true, true);
                                a_listPropItems.Add(poPropItem);

                                // used time 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.USED_TIME;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.TIME_SPAN, true, true);
                                a_listPropItems.Add(poPropItem);

                                // finish time 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.FINISH_TIME;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.TIME, true, true);
                                a_listPropItems.Add(poPropItem);

                                // completed fields 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.COMPLETED_FIELDS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MEASURE_RESULTS:
                        {
                            modelResource = ResourceID.GrpMeasureResult;
                            // has measure result?
                            if (HasMeasureResult())
                            {

                                // radio 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.RATIO;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total measured area 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total particles 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total particle area
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                        }
                        break;

                    default:
                        {
                            // something wrong here, return nullptr
                            break;
                        }
                }
                poPropItemGrp.SetItemsList(a_listPropItems);
                m_listPropItemGrp.Add(poPropItemGrp);
            }
            // return property items group
            return true; ;
        }

        public bool SetPropItemGrpsForCleanlinessSys()
        {
            if (m_listPropItemGrp != null)
            {
                if (m_listPropItemGrp.Count > 0)
                {
                    m_listPropItemGrp.Clear();
                }
            }
            // property items group
            OTS_SAMPLE_PROP_GRID_ITEM_GROUPS a_nId = 0;
            for (int i = (int)OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MIN; i <= (int)OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MAX; i++)
            {

                // items list
                List<CPropItem> a_listPropItems = new List<CPropItem>();
                a_nId = (OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)i;
                if (m_poMsrParams.m_runmode == RunMode.PlainMode)
                {
                    if (a_nId != OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.GENERAL)
                    {
                        break;//if it's plain mode then only display the general parameter section.
                    }

                }



                CPropItemGrp poPropItemGrp = new CPropItemGrp();
                // property items group name
                string strGrpName = string.Empty;
                strGrpName = ResourceData.GetSourceTitleString((OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)a_nId);
                if (strGrpName == "")
                {
                    return false;
                }
                // group name and id
                poPropItemGrp.SetName(strGrpName);
                poPropItemGrp.SetGroupId(a_nId);
                // set group items list
                OTS_SAMPLE_PROP_GRID_ITEMS nItemId;
                CPropItem poPropItem;
                bool bShow = true;
                //分组编号
                int modelResource = ResourceID.GrpGeneral;
                switch (a_nId)
                {
                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.GENERAL:
                        {
                            modelResource = ResourceID.GrpGeneral;
                            // name
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // hole
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_HOLE_NAME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // switch
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SWITCH;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.BOOL, false, bShow);
                            a_listPropItems.Add(poPropItem);

                        

                     

                            // STD file name
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.FILE_LIST, false, bShow);
                            a_listPropItems.Add(poPropItem);
                        

                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.IMAGESCAN:
                        {
                            modelResource = ResourceID.GrpImageScan;
                            // start mode
                            COTSImgScanPrm pScanParam = m_poMsrParams.GetImageScanParam();

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            //// stop mode

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, bShow);
                            a_listPropItems.Add(poPropItem);

                            
                            // particle

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_PARTICLE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_FIELD;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);

                            // used time

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_TIME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);


                            // area

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_AREA;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, false);
                            a_listPropItems.Add(poPropItem);

                            // scan speed

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // image resolution

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.IMAGE_PROCESS:
                        {
                            modelResource = ResourceID.GrpImageProcess;
                            COTSImageProcParam pProcParam = m_poMsrParams.GetImageProcessParam();

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.BGREMOVE_TYPE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            switch (m_poMsrParams.GetImageProcessParam().GetBGRemoveType())
                            {
                                case OTS_BGREMOVE_TYPE.AUTO:
                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.AUTOBGREMOVE_TYPE;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                                    a_listPropItems.Add(poPropItem);
                                    // particle area min

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    // particle area max

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    break;
                                case OTS_BGREMOVE_TYPE.MANUAL:
                                  

                                    // BG gray level min

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    // BG gray level max

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                    a_listPropItems.Add(poPropItem);
                                    //here,no longer consider the gray range of particles,for we can get the same result by regulate the background range.(gsp 2021.8.13)
                                    //---------------------------------------------
                                    // particle gray level min

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    // particle gray level max

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                                    a_listPropItems.Add(poPropItem);
                                    //----------------------------------------------

                                    // particle area min

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                    a_listPropItems.Add(poPropItem);

                                    // particle area max

                                    poPropItem = new CPropItem();
                                    nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX;
                                    poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                                    a_listPropItems.Add(poPropItem);



                                    break;

                            }
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.XRAY:
                        {
                            modelResource = ResourceID.GrpXray;
                            COTSXRayParam pXrayParam = m_poMsrParams.GetXRayParam();



                         
                            //using xray
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.USING_XRAY;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.BOOL, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // scan mode 

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.COMBO, false, bShow);
                            a_listPropItems.Add(poPropItem);
                            //quantify analysis min size

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_QUANTIFY_MINSIZE;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // analysis 

                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            //fast xray time.
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_FASTTIME;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // analysis counts 
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_COUNTS;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);

                            // XrayLimit 
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.XrayLimit;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, false, bShow);
                            a_listPropItems.Add(poPropItem);
                        }
                        break;
                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.SEM:
                        {
                            modelResource = ResourceID.GrpSEMParameter;
                            // does SEM data (measure) set?
                            CSEMDataMsr m_TempSEMDataMsr = new CSEMDataMsr();
                            if ((m_poSEMDataMsr.GetScanFieldSize100() == m_TempSEMDataMsr.GetScanFieldSize100())
                                && (m_poSEMDataMsr.GetTotalFields() == m_TempSEMDataMsr.GetTotalFields())
                                && (m_poSEMDataMsr.GetWorkingDistance() == m_TempSEMDataMsr.GetWorkingDistance())
                                && (m_poSEMDataMsr.GetScanFieldSize() == m_TempSEMDataMsr.GetScanFieldSize()))
                            {
                                // magnification
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // pixel size
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // working distance
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total field
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total area
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                            else
                            {
                                // magnification
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, true);
                                a_listPropItems.Add(poPropItem);

                                // pixel size
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, false, true);
                                a_listPropItems.Add(poPropItem);

                                // working distance
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total field
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total area
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MEASURE_STATUS:
                        {
                            modelResource = ResourceID.GrpMeasureState;
                            // measure status 
                            poPropItem = new CPropItem();
                            nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_STATAU;
                            poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.STRING, true, true);
                            a_listPropItems.Add(poPropItem);

                            // has measure result?
                            if (HasMeasureResult())
                            {
                                // start time 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.START_TIME;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.TIME, true, true);
                                a_listPropItems.Add(poPropItem);

                                // used time 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.USED_TIME;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.TIME_SPAN, true, true);
                                a_listPropItems.Add(poPropItem);

                                // finish time 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.FINISH_TIME;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.TIME, true, true);
                                a_listPropItems.Add(poPropItem);

                                // completed fields 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.COMPLETED_FIELDS;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                        }
                        break;

                    case OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MEASURE_RESULTS:
                        {
                            modelResource = ResourceID.GrpMeasureResult;
                            // has measure result?
                            if (HasMeasureResult())
                            {

                                // radio 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.RATIO;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.DOUBLE, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total measured area 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total particles 
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);

                                // total particle area
                                poPropItem = new CPropItem();
                                nItemId = OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE_AREA;
                                poPropItem.SetSmplParameter(modelResource, nItemId, OTS_ITEM_TYPES.INT, true, true);
                                a_listPropItems.Add(poPropItem);
                            }
                        }
                        break;

                    default:
                        {
                            // something wrong here, return nullptr
                            break;
                        }
                }
                poPropItemGrp.SetItemsList(a_listPropItems);
                m_listPropItemGrp.Add(poPropItemGrp);
            }
            // return property items group
            return true; ;
        }
        public List<CPropItemGrp> GetPropItemGrps()
        {
            return m_listPropItemGrp;
        }

        public bool GetRelatedPropItem(OTS_SAMPLE_PROP_GRID_ITEMS itemID, ref OTS_SAMPLE_PROP_GRID_ITEMS a_nRelatedPropId)
        {
            switch (itemID)
            {
                // general group
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_HOLE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SWITCH:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SYS_STD_SWITCH:
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_PARAM_FILE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME:
                // image param group
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_PARTICLE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_FIELD:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.INVALID;
                        return false;
                    }

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE;
                    }
                    break;

                // image process param
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX;
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN;
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX;
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN;
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX;
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN;
                    }
                    break;
                // x-ray param
                case OTS_SAMPLE_PROP_GRID_ITEMS.SEARCH_RESOLUTION:
                case OTS_SAMPLE_PROP_GRID_ITEMS.LOW_COUNTS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_COUNTS:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.INVALID;
                        return false;
                    }
                    break;

                // SEM data 
                case OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA:
                // measure status
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_STATAU:
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.USED_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.FINISH_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.COMPLETED_FIELDS:
                // measure results
                case OTS_SAMPLE_PROP_GRID_ITEMS.RATIO:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE_AREA:
                    {
                        a_nRelatedPropId = OTS_SAMPLE_PROP_GRID_ITEMS.INVALID;
                        return false;
                    }
                    break;

                default:
                    {
                        // something wrong, return FALSE
                        return false;
                    }
                    break;

            }

            // ok, return TRUE
            return true;
        }
        public bool GetRelatedPropItemGrp(OTS_SAMPLE_PROP_GRID_ITEMS itemID, ref OTS_SAMPLE_PROP_GRID_ITEM_GROUPS groupID)
        {
            switch (itemID)
            {
                // general group
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_HOLE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SWITCH:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SYS_STD_SWITCH:
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_PARAM_FILE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME:
                // image param group
                // image param group
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_PARTICLE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_FIELD:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_PARAM_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED:
                    {
                        groupID = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.IMAGE_PROCESS;
                        return false;
                    }

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION:
                    {
                        groupID = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.IMAGE_PROCESS;
                    }
                    break;
                // image process param
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN:
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX:
                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MIN:
                case OTS_SAMPLE_PROP_GRID_ITEMS.BG_GRAY_MAX:
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MIN:
                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_GRAY_MAX:
                // x-ray param
                case OTS_SAMPLE_PROP_GRID_ITEMS.SEARCH_RESOLUTION:
                case OTS_SAMPLE_PROP_GRID_ITEMS.LOW_COUNTS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_COUNTS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA:
                // measure status
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_STATAU:
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.USED_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.FINISH_TIME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.COMPLETED_FIELDS:
                // measure results
                case OTS_SAMPLE_PROP_GRID_ITEMS.RATIO:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE_AREA:
                    {
                        groupID = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.MEASURE_RESULTS;
                        return false;
                    }
                    break;

                default:
                    {
                        // something wrong, return FALSE
                        groupID = OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.INVALID;
                        return false;
                    }
                    break;

            }

            // ok, return TRUE
            return true;
        }

        // double data (4)
        public bool GetPropdoubleData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, out double a_dValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION:
                    {
                        a_dValue = m_poSEMDataMsr.GetMagnification();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE:
                    {
                        a_dValue = CalculatePixelSize();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE:
                    {
                        a_dValue = m_poSEMDataMsr.GetWorkingDistance();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.RATIO:
                    {
                        a_dValue = m_poMsrResults.GetRatio();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MIN:
                    {
                        a_dValue = m_poMsrParams.GetImageProcessParam().GetIncAreaRange().GetStart();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.PARTICLE_AREA_MAX:
                    {
                        a_dValue = m_poMsrParams.GetImageProcessParam().GetIncAreaRange().GetEnd();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA:
                    {

                        double dFieldArea = 0; // this area should be the field area
                        dFieldArea = CalculateAFieldArea();
                        a_dValue = m_poSEMDataMsr.GetTotalFields() * dFieldArea;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_AREA:
                    {
                        a_dValue = m_poMsrResults.GetMeasuredArea();
                    }
                    break;


                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_PARTICLE_AREA:
                    {
                        a_dValue = m_poMsrResults.GetTotalParticleArea();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.XRAY_QUANTIFY_MINSIZE:
                    {
                        a_dValue = m_poMsrParams.GetXRayParam().GetFeatureModeMinSize();
                    }
                    break;

                default:
                    {
                        // something wrong, return false
                        a_dValue = -1;
                        return false;
                    }

            }

            // ok, return true
            return true;
        }


        // string data (7)
        public bool GetPropStringData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, out string a_strValue)
        {

            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME:
                    {
                        a_strValue = m_strName;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_HOLE_NAME:
                    {
                        a_strValue = m_strHoleName;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION:
                    {
                        a_strValue = NOT_APPLIED;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE:
                    {
                        a_strValue = NOT_APPLIED;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE:
                    {
                        a_strValue = NOT_APPLIED;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS:
                    {
                        a_strValue = NOT_APPLIED;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA:
                    {
                        a_strValue = NOT_APPLIED;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_STATAU:
                    {
                        OTS_MSR_SAMPLE_STATUS nStatus = m_Status.GetStatus();
                        string strStatus = nStatus.ToString();
                        strStatus = XmlResourceData.GetInstance().GetStringByKey(GrpMeasureResult, IDS_MEASURE_STATUS_FIRST + (int)nStatus);
                        a_strValue = strStatus;
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE:
                    {
                        a_strValue = m_poMsrParams.GetImageScanParam().GetStopMode();
                    }
                    break;

                default:
                    {
                        // something wrong, return false
                        a_strValue = NOT_APPLIED;
                        return false;
                    }
                    //break;

            }

            // ok, return true
            return true;
        }
        public bool SetPropStringData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, string a_strValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME:
                    {
                        //we think the samplename as the Identification of the sample,if we change the name then reset the status.
                        //so we can remeasure the sample by change the sample name.
                        if (m_strName != a_strValue)
                        {
                            m_strName = a_strValue;
                            m_Status = new CMsrSampleStatus();
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE:
                    {
                        if (m_poMsrParams.GetImageScanParam().GetStopMode() != a_strValue)
                        {
                            m_poMsrParams.GetImageScanParam().SetStopMode(a_strValue);
                        }
                    }
                    break;

                // read only property, tread as default. 
                case OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_HOLE_NAME:
                case OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION:
                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGERESOLUTION_SIZE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_FIELDS:
                case OTS_SAMPLE_PROP_GRID_ITEMS.TOTAL_TO_MEASURE_AREA:
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_STATAU:
                default:
                    {
                        // something wrong, return false
                        return false;
                    }
                    //break;

            }

            // ok, return true
            return true;
        }

        // combo data (7)
        public bool GetPropComboData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, out int a_nValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE:
                    {
                        a_nValue = (int)m_poMsrParams.GetImageScanParam().GetFieldStartMode();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED:
                    {
                        a_nValue = (int)m_poMsrParams.GetImageScanParam().GetScanImageSpeed();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION:
                    {
                        a_nValue = (int)m_poMsrParams.GetImageScanParam().GetImageResulotion();
                    }
                    break;

           

                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                    {
                        a_nValue = (int)m_poMsrParams.GetXRayParam().GetAnalySpeed();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE:
                    {
                        a_nValue = (int)m_poMsrParams.GetXRayParam().GetScanMode();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEMBRANE_TYPE:
                    {
                        a_nValue = (int)this.GetMembraneType();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELD_STOP_TYPE:
                    {
                        a_nValue = (int)m_poMsrParams.GetImageScanParam().GetFieldStopMode();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.BGREMOVE_TYPE:
                    {
                        a_nValue = (int)m_poMsrParams.GetImageProcessParam().GetBGRemoveType();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.AUTOBGREMOVE_TYPE:
                    {
                        a_nValue = (int)m_poMsrParams.GetImageProcessParam().GetAutoBGRemoveType();
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.STEEL_TECHNOLOGY:
                    {
                        a_nValue = (int)m_poMsrParams.GetSteelTechnology();
                    }
                    break;
                default:
                    {
                        // something wrong, return false
                        a_nValue = 0;
                        return false;
                    }
                    //break;

            }

            // ok, return true
            return true;
        }
        public bool SetPropComboData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, int a_nValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.STEEL_TECHNOLOGY:
                    {
                        if (STEEL_TECHNOLOGY.GeneralProcessMode > (STEEL_TECHNOLOGY)a_nValue || (STEEL_TECHNOLOGY)a_nValue > STEEL_TECHNOLOGY.RareEarthMode)
                        {
                            return false;
                        }

                        m_poMsrParams.SetSteelTechnology((STEEL_TECHNOLOGY)a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE:
                    {
                        if (OTS_GET_IMAGE_MODE.FROM_CENTER > (OTS_GET_IMAGE_MODE)a_nValue || (OTS_GET_IMAGE_MODE)a_nValue > OTS_GET_IMAGE_MODE.DOWN_TO_UP)
                        {
                            return false;
                        }

                        m_poMsrParams.GetImageScanParam().SetStartImageMode((OTS_GET_IMAGE_MODE)a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED:
                    {
                        if (OTS_IMAGE_SCANSPEED_OPTIONS.low > (OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue || (OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue > OTS_IMAGE_SCANSPEED_OPTIONS.high)
                        {
                            return false;
                        }
                        m_poMsrParams.GetImageScanParam().SetScanImageSpeed((OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION:
                    {
                        if (OTS_IMAGE_RESULOTION_OPTIONS._512_384 > (OTS_IMAGE_RESULOTION_OPTIONS)a_nValue || (OTS_IMAGE_RESULOTION_OPTIONS)a_nValue > OTS_IMAGE_RESULOTION_OPTIONS._4096_3072)
                        {
                            return false;
                        }
                        m_poMsrParams.GetImageScanParam().SetImageResulotion((OTS_IMAGE_RESULOTION_OPTIONS)a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SEARCH_RESOLUTION:
                    {
                        if (OTS_IMAGE_SCANSPEED_OPTIONS.low > (OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue || (OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue > OTS_IMAGE_SCANSPEED_OPTIONS.high)
                        {
                            return false;
                        }
                        //m_poMsrParams.GetXRayParam().SetSearchSpeed((OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                    {
                        if (OTS_IMAGE_SCANSPEED_OPTIONS.low > (OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue || (OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue > OTS_IMAGE_SCANSPEED_OPTIONS.high)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetAnalySpeed((OTS_IMAGE_SCANSPEED_OPTIONS)a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE:
                    {
                        if (OTS_X_RAY_SCAN_MODE.PointMode > (OTS_X_RAY_SCAN_MODE)a_nValue || (OTS_X_RAY_SCAN_MODE)a_nValue > OTS_X_RAY_SCAN_MODE.FeatureMode)
                        {
                            return false;
                        }
                        m_poMsrParams.GetXRayParam().SetScanMode((OTS_X_RAY_SCAN_MODE)a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.MEMBRANE_TYPE:
                    {
                        if (MEMBRANE_TYPE.MIN > (MEMBRANE_TYPE)a_nValue || (MEMBRANE_TYPE)a_nValue > MEMBRANE_TYPE.MAX)
                        {
                            return false;
                        }
                        this.SetMembraneType((MEMBRANE_TYPE)a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FIELD_STOP_TYPE:
                    {
                     
                        m_poMsrParams.GetImageScanParam().SetFieldStopMode((OTS_MEASURE_FIELD_STOP_MODE)a_nValue);
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.BGREMOVE_TYPE:
                    {
                    
                        m_poMsrParams.GetImageProcessParam().SetBGRemoveType((OTS_BGREMOVE_TYPE)a_nValue);
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.AUTOBGREMOVE_TYPE:
                    {
                    
                        m_poMsrParams.GetImageProcessParam().SetAutoBGRemoveType((OTS_AUTOBGREMOVE_TYPE)a_nValue);
                    }
                    break;
                default:
                    {
                        // something wrong, return false
                        return false;
                    }
                    //break;

            }

            // ok, return true
            return true;
        }
        public bool GetPropComboStrings(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, List<string> a_listComboStrings)
        {


            // clear the strings list
            a_listComboStrings.Clear();

            // set the strings list
            string strItem;
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_MODE:
                    {
                        for (int i = (int)OTS_GET_IMAGE_MODE.FROM_CENTER; i <= (int)OTS_GET_IMAGE_MODE.DOWN_TO_UP; ++i)
                        {
                            //ResourceID;
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpImageScan, IDS_IMAGE_MODE_FIRST + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.STOP_MODE:
                    {
                        for (int i = (int)OTS_MEASURE_STOP_MODE.CoverMode; i <= (int)OTS_MEASURE_STOP_MODE.TimeMode; ++i)
                        {
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpImageScan, IDS_MEASURE_STOP_MODE_FIRST + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_SPEED:
                case OTS_SAMPLE_PROP_GRID_ITEMS.SEARCH_RESOLUTION:
                    //case OTS_SAMPLE_PROP_GRID_ITEMS.ANALYSIS_RESOLUTION:
                    {
                        for (int i = (int)OTS_IMAGE_SCANSPEED_OPTIONS.low; i <= (int)OTS_IMAGE_SCANSPEED_OPTIONS.high; ++i)
                        {
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpImageScan, IDS_THREE_TIES_OPTIONS_FIRST + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION:
                    {
                        for (int i = 0; i < Enum.GetValues(typeof(OTS_IMAGE_RESULOTION_OPTIONS)).Length; i++)
                        {
                            strItem = RESOLUTION_STRINGS[RESOLUTION_ID_FIRST_TIE + i];
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.SCAN_MODE:
                    {
                        for (int i = (int)OTS_X_RAY_SCAN_MODE.PointMode; i <= (int)OTS_X_RAY_SCAN_MODE.FeatureMode; ++i)
                        {
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpXray, IDS_X_RAY_SCAN_MODE_FIRST + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.STEEL_TECHNOLOGY:
                    {
                        for (int i = (int)STEEL_TECHNOLOGY.GeneralProcessMode; i <= (int)STEEL_TECHNOLOGY.RareEarthMode; ++i)
                        {
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpGeneral, IDS_STEEL_TECHNOLOGY + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.BGREMOVE_TYPE:
                    {
                        for (int i = 0; i <(int)Enum.GetValues(typeof(OTS_BGREMOVE_TYPE)).Length; ++i)
                        {
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpImageProcess, IDS_BGREMOVE_TYPE + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.AUTOBGREMOVE_TYPE:
                    {
                        for (int i = (int)OTS_AUTOBGREMOVE_TYPE.MIDDLE; i <= (int)OTS_AUTOBGREMOVE_TYPE.UPWARD; ++i)
                        {
                            strItem = XmlResourceData.GetInstance().GetStringByKey(GrpImageProcess, IDS_AUTOBGREMOVE_TYPE + i);
                            a_listComboStrings.Add(strItem);
                        }
                    }
                    break;

                default:
                    {
                        // something wrong, return false
                        return false;
                    }
                    //break;

            }

            // ok, return true
            return true;
        }

        // time data
        public bool GetPropTimeData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, ref DateTime a_oValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_TIME:
                    {
                        a_oValue = m_Status.GetStartTime();
                    }
                    break;

                case OTS_SAMPLE_PROP_GRID_ITEMS.FINISH_TIME:
                    {
                        a_oValue = m_Status.GetEndTime();
                    }
                    break;

                default:
                    {
                        // something wrong, return false
                        return false;
                    }


            }

            // ok, return true
            return true;
        }


        public bool SetPropTimeData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, DateTime a_oValue)
        {
            switch (a_nId)
            {
                // read only property, tread as default. 
                case OTS_SAMPLE_PROP_GRID_ITEMS.START_TIME:
                    break;
                case OTS_SAMPLE_PROP_GRID_ITEMS.FINISH_TIME:
                    break;
                default:
                    {
                        // something wrong, return false
                        return false;
                    }


            }

            // ok, return true
            return true;
        }
        // time span data (1)
        public bool GetPropTimeSpanData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, ref TimeSpan a_oValue)
        {
            switch (a_nId)
            {
                case OTS_SAMPLE_PROP_GRID_ITEMS.USED_TIME:
                    {
                        a_oValue = m_Status.GetUsedTime();
                    }
                    break;

                default:
                    {
                        // something wrong, return false
                        return false;
                    }


            }

            // ok, return true
            return true;
        }
        public bool SetPropTimeSpanData(OTS_SAMPLE_PROP_GRID_ITEMS a_nId, TimeSpan a_oValue)
        {
            switch (a_nId)
            {
                // read only property, tread as default. 
                case OTS_SAMPLE_PROP_GRID_ITEMS.USED_TIME:
                    break;
                default:
                    {
                        // something wrong, return false
                        return false;
                    }


            }

            // ok, return true
            return true;
        }
        public double CalculatePixelSize()
        {
            // pixel size 
            double dPixelSize = 0.0;

            // make sure SEM is valid
            if (m_poSEMDataMsr != new CSEMDataMsr())
            {
                // get scan field size
                int nScanFieldSize = m_poSEMDataMsr.GetScanFieldSize();

                // get image size
                OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
                long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
                int nImageSize = RESOLUTION_VALUE[nResulotionId].Width;

                // calculate pixel size 
                dPixelSize = (double)nScanFieldSize / (double)nImageSize;
            }

            // return pixel size 
            return dPixelSize;
        }

        public Size GetResolutionSize()
        {
             // get scan field size
             int nScanFieldSize = m_poSEMDataMsr.GetScanFieldSize();
            // get image size
            OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
            long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
            return RESOLUTION_VALUE[nResulotionId];
        }

        public CPropItem GetPropItemById(OTS_SAMPLE_PROP_GRID_ITEMS a_nId)
        {
            CPropItem pPropItem = new CPropItem();
            bool isExist = false;
            if (m_listPropItemGrp.Count > 0)
            {
                foreach (CPropItemGrp poPropItemGrp in m_listPropItemGrp)
                {
                    List<CPropItem> listPropItems = poPropItemGrp.GetItemsList();
                    if (listPropItems.Count > 0)
                    {
                        foreach (CPropItem cPropItem in listPropItems)
                        {
                            if (cPropItem.GetSmplItemId() == a_nId)
                            {
                                pPropItem = cPropItem;
                                isExist = true;
                                break;
                            }
                        }
                        if (isExist)
                        {
                            break;
                        }
                    }
                }
            }
            return pPropItem;
        }
        public string GetItemValueStr(OTS_SAMPLE_PROP_GRID_ITEMS ItemID)
        {
            COTSSample cSample = new COTSSample();
            //CString strItemID = ItemId;
            string valStr = "";
            CPropItem itm = GetPropItemById(ItemID);
            switch ((OTS_ITEM_TYPES)itm.GetTypeId())
            {
                case OTS_ITEM_TYPES.BOOL:
                    {
                        bool bflag = false;
                        if (GetPropBOOLData((int)ItemID, out bflag))
                        {
                            valStr = bflag ? "1" : "0";
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.INT:
                    {
                        int iVal = 0;
                        if (GetPropIntData(ItemID, out iVal))
                        {
                            valStr = iVal.ToString();
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.DOUBLE:
                    {
                        double dVal = 0;
                        if (GetPropdoubleData(ItemID, out dVal))
                        {
                            valStr = dVal.ToString("f2");//点后面几个0就保留几位                                                                          
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.STRING:
                    {
                        string StrVal = "";
                        if (GetPropStringData(ItemID, out StrVal))
                        {
                            valStr = StrVal;
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.COMBO:
                    {
                        List<string> StrVal = new List<string>();
                        if (GetPropComboStrings(ItemID, StrVal))
                        {
                            int index = 0;
                            GetPropComboData(ItemID, out index);
                            if (index > (int)StrVal.Count)
                            {
                                valStr = StrVal[0];
                                break;
                            }
                            valStr = StrVal[index];
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.TIME:
                    {
                        System.DateTime dt = new System.DateTime();
                        if (GetPropTimeData(ItemID, ref dt))
                        {
                            valStr = dt.ToString();
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.TIME_SPAN:
                    {
                        System.TimeSpan TimeSpanValue = new System.TimeSpan();
                        if (GetPropTimeSpanData(ItemID, ref TimeSpanValue))
                        {
                            int v = (int)TimeSpanValue.TotalSeconds;
                            valStr = v.ToString();
                        }

                    }
                    break;
                case OTS_ITEM_TYPES.FILE_LIST:
                    {
                        //CMsrParams object represent a project param file. It includes PartSTD file ImgProcessParam ImgScanParam XrayParam four parts content.
                      
                        if (OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_PARAM_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)ItemID)
                        {
                            valStr = m_poMsrParams.GetName();

                        }

                        if (OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)ItemID)
                        {
                            valStr = m_poMsrParams.GetSTDName();

                        }

                    }
                    break;
                default:
                    break;
            }
            return valStr;
        }

        // calculate field area
        public double CalculateAFieldArea()
        {

            // pixel size 
            double dAFieldArea = 0.0;

            // make sure SEM is valid
            if (m_poSEMDataMsr != new CSEMDataMsr())
            {
                // get image size
                OTS_IMAGE_RESULOTION_OPTIONS nImageSizeId = m_poMsrParams.GetImageScanParam().GetImageResulotion();
                long nResulotionId = RESOLUTION_ID_FIRST_TIE + (long)nImageSizeId;
                int nImageSize = RESOLUTION_VALUE[nResulotionId].Width;
                int nHeight = RESOLUTION_VALUE[nResulotionId].Height;
                // pixel size (micros)
                double dPixelSize = 0;
                dPixelSize = CalculatePixelSize();

                // calculate pixel size 
                dAFieldArea = (double)nImageSize * nHeight * dPixelSize * dPixelSize * 0.000001;// mm^2
            }

            // return pixel size 
            return dAFieldArea;

        }
        public bool CalculateFieldData(out List<Point> pFields, out Size iSzie)
        {
            pFields = new List<Point>();
            iSzie = new Size();

            CDomain pMsrArea = GetMsrArea();


            COTSImgScanPrm pImgScanParam =GetMsrParams().GetImageScanParam();

            CSEMDataMsr pSEMDataMsr = GetSEMDataMsr();

            CFieldPositionMgr pFieldMgr = new CFieldPositionMgr();
            List<PointF> listPoint = new List<PointF>();
            listPoint.Clear();
           
            ////计算所有的帧图位置  calculate all the field position point in OTS coordination.
            if (!pFieldMgr.Init(pMsrArea, pImgScanParam, pSEMDataMsr, listPoint))
            {
                return false;
            }
            //获取幁图的中心点
            pFields = pFieldMgr.GetFieldCentrePoints();

            //获取幁图数
            int iFieldCount = pFieldMgr.GetTotalFields();

            var oValue = new Rectangle();
            if (!pFieldMgr.GetFieldRectByIndex(0, ref oValue))
            {
                return false;
            }
            iSzie = oValue.Size;

           GetSEMDataMsr().SetTotalFields(iFieldCount);



            return true;
        }

  

        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
            xString xstrSampleName = new xString();
            xString xstrHoleName = new xString();
            xBool xParamLock = new xBool();
            xBool xSwitch = new xBool();
            xBool xSysSTDSwitch = new xBool();
            Collection<COTSFieldData> fielddata = new Collection<COTSFieldData>();
            Slo slo = new Slo();
            slo.Register("SampleName", xstrSampleName);
            slo.Register("HoleName", xstrHoleName);
            slo.Register("ParamLock", xParamLock);
            slo.Register("Switch", xSwitch);
            slo.Register("UseSysSTD", xSysSTDSwitch);
            slo.Register("MsrArea", m_poMsrArea);
            slo.Register("MsrParams", m_poMsrParams);
            slo.Register("SEMDataMsr", m_poSEMDataMsr);
            slo.Register("AllFields", fielddata);
            if (isStoring)
            {
                xstrSampleName.AssignValue(m_strName);
                xstrHoleName.AssignValue(m_strHoleName);
                xParamLock.AssignValue(m_bParamLock);
                xSwitch.AssignValue(m_bSwitch);
                foreach (var f in m_listFieldData)
                {
                    fielddata.addItem(f);
                }
              
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);
                m_strName = xstrSampleName.value();
                m_strHoleName = xstrHoleName.value();
                m_bParamLock = xParamLock.value();
                m_bSwitch = xSwitch.value();

                foreach (var f in fielddata.m_vCollection)
                {
                    var fld = (COTSFieldData)f;
                    int w, h;
                    this.GetBSESize(out w,out h);
                    fld.Width = w;fld.Height = h;
                    fld.SetPixelSize(CalculatePixelSize());
                    
                    m_listFieldData.Add((COTSFieldData)f);
                }
            }
        }
    }
}