using OTSModelSharp;
using OTSDataType;
using NSOTSController;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.IO;
using OTSIncAMeasureApp.OTSMeasureThread;

namespace OTSIncAMeasureApp
{

    public enum OTS_SOFT_PACKAGE_ID
    {
        OTSIncA = 0,             //夹杂物分析
        OTSPartA = 1,            //颗粒度分析
    };

    //文件保存返回的结果，DataMgr返回
    public enum OTS_SAVE_FILE_REV
    {
        SaveFile_Success = 0,
        SaveFile_Cancel = 1,
        SaveFile_Failed = 2,
        SaveFile_NoNedd = 3      //文件不需要保存
    }

    //设置线程状态
    public enum MSR_THREAD_STATUS
    {
        INPROCESS = 1,         //开始测量
        STOPPED = 2,            //测量停止
        StartImageCollect = 3,  //开始图像采集
        STOPPEDImageCollect = 4 //停止图像采集
    };

    //设置线程状态
    public enum MSR_THREAD_RunSTATUS
    {
        RUNMEASURE = 1,         //开始测量
        RUNSampleHoleImage = 2  //运行获取样品孔照片
    };

    public class OTSDataMgrFun 
    {
        OTSIncAMeasureAppForm m_MeasureAppFrom = null;
        // 工作文件。c++ 接口，主要用来操作数据管理类的样品测量数据交换, 工作文件类，所有样品信息都从此类中获得          
       // public CProjMgrClr m_ProjDataMgr = new CProjMgrClr();

        public COTSProjMgrFile m_ProjDataMgr = new COTSProjMgrFile();

        
        //参数文件管理。选择OTSIncA和OTSPartA, 读取样品参数。
        public COTSProgMgr m_ProgMgr = new COTSProgMgr();
        //参数文件
        public COTSProgMgrParamFile m_ProgParamFile = null;
        //样品台文件（读取样品台数据等)                            
        CStageFile m_StageFile = null;          
        // 用于绘制样品台的数据
        public OTSSampleStageData m_SStageData = null;
        //样品测量参数
        //测量线程类
        CMsrThread m_MsrThread = null;
        //测量样品链表
        List<COTSSample> m_MeasureSampleList = new List<COTSSample>();

        NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();

        public OTSDataMgrFun(OTSIncAMeasureAppForm MeasureApp)
        {
            m_MeasureAppFrom = MeasureApp;
            m_SStageData = new OTSSampleStageData();
            
            
        }
                      
        //判断系统文件是否存在
        public bool SystemFileExit()
        {
            return m_ProjDataMgr.IsValid();
        }
       
       
       
        //检查参数文件是否存在
        public bool LoadParamFile()
        {
            //加载样品参数文件:   \Config\SysData\OTSProgMgrParam.pmf
            m_ProgParamFile = new COTSProgMgrParamFile();
            m_ProgParamFile.LoadInfoFromProgMgrFile((int)OTS_SOFT_PACKAGE_ID.OTSIncA);
            if (null == m_ProgParamFile)
            {              
                return false;
            }
            return true;
        }

        //检查参数样品台文件是否存在
        public bool LoadStageParamFile()
        {
            m_StageFile = new CStageFile();
            // 加载样品台文件；  \Config\SysData\OTSStage.stg
            if (!m_StageFile.Load((int)OTS_SOFT_PACKAGE_ID.OTSIncA, true, false))
            {                
                return false;
            }
            if (!SetStageData())
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 将配置文件中样品台信息 设置给样品台对象中
        /// </summary>
        /// <returns></returns>
        public bool SetStageData()
        {
            CSEMStageData SEMStageData;
            if (m_ProgParamFile == null)
            {
                return false;
            }
            SEMStageData = m_ProgParamFile.GetStageDataParam();
            if (m_StageFile == null)
            {
                return false;
            }
            m_StageFile.SetStageData(SEMStageData);
            return true;
        }

        //获取系统文件是否存在和有效
        //bool bNewFileFlag = true:  New 文件
        public bool InitProjMgr(bool bNewFileFlag = true)
        {
            //打开文件，则文件中保存有样品台信息，不需要使用系统样品名信息
            if (bNewFileFlag)
            {

            //设置样品台参数
            CStage Stage = m_StageFile.GetWorkingStage();
            if (null == Stage)
            {                  
                return false;
            }
            m_ProjDataMgr.SetStage(Stage);


            // 设置 SEM stage data
            CSEMStageData SEMData = m_StageFile.GetStageData();
            if (null == SEMData)
            {
                return false;
            }
                m_ProjDataMgr.SetSEMStageData(SEMData);
            }

            //设置 general parameter
            COTSGeneralParameters GenParam = m_ProgParamFile.GetGenParam();
            if (null == GenParam)
            {              
                return false;
            }
            m_ProjDataMgr.SetGenParam(GenParam);
            //设置 general parameter
            COTSImgScanPrm ImageScan = m_ProgParamFile.GetImageScanParam();
            if (null == ImageScan)
            {              
                return false;
            }
            m_ProjDataMgr.SetImageScanParam(ImageScan);
            //设置 image process parameter
            COTSImgProcPrm ImageProc = m_ProgParamFile.GetImageProcParam();
            if (null == ImageProc)
            {                
                return false;
            }
            m_ProjDataMgr.SetImageProcParam(ImageProc);
            //设置 XRay parameter
            COTSXRayParam XRayParam = m_ProgParamFile.GetXRayParam();
            if (null == XRayParam)
            {               
                return false;
            }
            m_ProjDataMgr.SetXRayParam(XRayParam);

            //判断以上6类参数设置是否成功
            if (!m_ProjDataMgr.IsValid())
            {
                return false;
            }

            if (bNewFileFlag)
            {
                //产生样品新文件
                if (!m_ProjDataMgr.NewFile())
                {
                    return false;
                }
            }

            //获取样品台信息  CStageClr  
            if (!this.GetSampleStageData())
            {
                return false;
            }
              return true;
        }
      
        //获取绘制样品台的数据
        public bool GetSampleStageData()
        {
            //获取样品台信息
            CStage SStage = m_ProjDataMgr.GetStage();
            if (null == SStage)
            {               
                return false;
            }

            //获得样品台数据
            m_SStageData.sStageName = SStage.GetName();
            m_SStageData.bStageShape = (int)SStage.GetBoundary().GetShape();
            m_SStageData.StageDomain = (Rectangle)SStage.GetBoundary().GetRectDomain();
            m_SStageData.bSampleShape = (int)SStage.GetSTD().GetShape();
            m_SStageData.SampleRect = (Rectangle)SStage.GetSTD().GetRectDomain();
            int iSHoleCount = SStage.GetHoleList().Count();    //样品孔个数           
            if (m_SStageData.sSHoleInfoList.Count() > 0)
            {
                m_SStageData.sSHoleInfoList.Clear();
            }
            var holeLst = SStage.GetHoleList();
            for (int i = 0; i < iSHoleCount; i++)
            {
                CHole d = holeLst[i];
                OTSSampleHoleInfo SHoleInfo = new OTSSampleHoleInfo();
            //获取样品口的名称，形状，坐标
            SHoleInfo.sSHoleName = d.GetName();
            SHoleInfo.iSHoleShape =(int)d.GetShape();
                
                Rectangle r =(Rectangle)d.GetRectDomain();

            SHoleInfo.HoleRect =r;
            m_SStageData.sSHoleInfoList.Add(SHoleInfo);
            }

            //获取SEMData 绘制样品
            m_SStageData.iScanFieldSize100 = m_ProjDataMgr.GetSEMStageData().GetScanFieldSize100();  //放大倍数为100倍时的屏幕尺寸
            m_SStageData.iXAxisDir =(int) m_ProjDataMgr.GetSEMStageData().GetXAxisDir();
            m_SStageData.iYAxisDir = (int)m_ProjDataMgr.GetSEMStageData().GetYAxisDir();
            m_SStageData.iXAxisStartVal = m_ProjDataMgr.GetSEMStageData().GetXAxis().GetStart();
            m_SStageData.iXAxisEndVal = m_ProjDataMgr.GetSEMStageData().GetXAxis().GetEnd();
            m_SStageData.iYAxisStartVal = m_ProjDataMgr.GetSEMStageData().GetYAxis().GetStart();
            m_SStageData.iYAxisEndVal = m_ProjDataMgr.GetSEMStageData().GetYAxis().GetEnd();

            return true;
        }

        //新建样品工作文件
        public bool CreateNewFile()
        {
            if (m_ProjDataMgr.IsModified())    // 文件被修改
            {
                int iRev = m_MeasureAppFrom.ShowSaveInfoMsgBox();
                if ((int)MessageBoxRev.DIALOG_YES == iRev)
                {
                    if (!m_ProjDataMgr.Save())
                    {
                        
                        return false;
                    }
                }
            }

            //新建新的工作文件
            //重新生成一个工作文件对象
            COTSProjMgrFile ProjDataMgr = new COTSProjMgrFile();

            if (!m_ProjDataMgr.NewFile())
            {               
                return false;
            }

            m_ProjDataMgr = ProjDataMgr;
            this.LoadStageParamFile();
            //m_ProgMgr.SetPackId((int)OTS_SOFT_PACKAGE_ID.OTSIncA);
            if (!this.InitProjMgr())
            {               
                return false;
            }
            
               return true;
        }

        //打开已存在的样品台工作文件, 返回True，打开新文件成功; 返回False，打开新文件失败；
        public bool OpenExistSampleFile()
        {
            //打开新文件
            //产生新的文件
            //重新生成一个工作文件对象
            COTSProjMgrFile ProjDataMgr = new COTSProjMgrFile();
            if (ProjDataMgr.Load())
            {
                m_ProjDataMgr = ProjDataMgr;
                if (!this.InitProjMgr(false))
                {                    
                    return false;
                }                
                return true;
            }                        
                   return false;
        }

        //保存样品文件
        public bool SaveProjFile()
        {
            string SampleName = GetWorkSampleName();
            if (SampleName == "") {

                return false;
            }
            return m_ProjDataMgr.Save();
        }

        //另存文件
        public bool SaveAsProjFile()
        {
           return m_ProjDataMgr.SaveAs();
        }

        //检查测量区域是否超过样品台区域
        //RMeasureArea: 样品台的当前测量区域；  RStageArea： 样品台区域；  RMeasureArea《RStageArea
        public bool CheckMeasureAreaIsByondStageArea(Rectangle RMeasureArea, Rectangle RStageArea, int iShape)
        {          
        Rectangle pMeasureArea = RMeasureArea;
        Rectangle pStageArea = RStageArea;
        CDomain a_DomainMeasureArea = new CDomain((otsdataconst.DOMAIN_SHAPE)iShape, pMeasureArea);
        CDomain a_DomainStageArea = new CDomain((otsdataconst.DOMAIN_SHAPE)iShape, pStageArea);
        return a_DomainStageArea.DomainInDomain(a_DomainMeasureArea);
        }

        //将样品台坐标转换为Sem 坐标
        public Point ChangeOTSToSemCoord(Point POTSCoord)
        {
            System.Drawing.Point VSemCoord = new System.Drawing.Point();
        m_StageFile.ConverOTSToSEMPoint(POTSCoord, ref VSemCoord);
        return (Point)VSemCoord;
        }

        //将Sem 坐标转换为样品台坐标
        public Point ConverSEMToOTSPoint(Point PSEMCoord)
        {
            System.Drawing.Point VOTSCoord = new System.Drawing.Point();
            m_StageFile.ConverSEMToOTSPoint(PSEMCoord, ref VOTSCoord);
            return (Point)VOTSCoord;
        }

        //添加样品
        //string sSHoleName:  样品孔名,当在样品孔上点击右键添加样品时，sSHoleName=样品孔名。当MEASUREAPP和TREEVIEW添加样品时，sSHoleName=""
        //返回新的工作样品名称
        public OTSSampleMeaInfo AddNewSampleMeasure(string sSHoleName = "")
        {
            //添加样品
            COTSSample NewSample = m_ProjDataMgr.AddSample(sSHoleName);
            if (null == NewSample)
            {               
                return null;
            }
            // 获取样品的属性值
            OTSSampleMeaInfo MeasureInfo = new OTSSampleMeaInfo();
            if (!GetWorkSamplePropertyVal(NewSample, ref MeasureInfo))
            {
                return null;
            }

            ///初始化STD
            //SetSTDFileName(0);

            return MeasureInfo;
        }

        //设置工作样品的属性值
        public bool SetSampleParamVal(OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS ItemId, OTS_ITEM_TYPES ValType, object objVal)
        {

            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();

            bool bSetFalg = false;

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

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

                case OTS_ITEM_TYPES.DOUBLE:
                    {
                        //设置工作样品值失败
                        if (!WSample.SetPropdoubleData(ItemId, Convert.ToDouble(objVal)))   
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;
                case OTS_ITEM_TYPES.STRING:
                    {
                        //判断样品名是否有效
                        if (ItemId == OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS.SAMPLE_NAME)
                        {
                        if (!m_ProjDataMgr.IsValidSampleName((string)objVal))
                        {                               
                            bSetFalg = false;
                            break;
                        }
                        }
                        //设置工作样品值失败
                        if (!WSample.SetPropStringData(ItemId, (string)objVal))  
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }
                    }
                    break;
                case OTS_ITEM_TYPES.COMBO:
                    {
                        //设置工作样品值失败
                        if (!WSample.SetPropComboData(ItemId, (int)objVal))   
                        {
                            bSetFalg = false;
                        }
                        else
                        {
                            bSetFalg = true;
                        }

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

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

                    bSetFalg = false;
                    break;
            }

            if (bSetFalg)
            {
                m_ProjDataMgr.SetModify(true);
            }
            return bSetFalg;
        }

        //获取工作样品名称
        public string GetWorkSampleName()
        {
           
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {                
                return "";
            }
            string sWorkSampleName = WSample.GetName();
            if ("" == sWorkSampleName)
            {               
                return "";
            }

            return sWorkSampleName;
        }

        //设置工作样品
        //string sNewWorkSampleName:  新工作样品
        public bool SetWorkSample(string sNewWorkSampleName)
        {
            if ("" == sNewWorkSampleName)
            {
                return false;
            }

            if (!m_ProjDataMgr.SetWorkingSampleByName(sNewWorkSampleName))
            {
                return false;
            }
            return true;
        }

        //获取工作样品
        // 返回工作样品对象
        public COTSSample GetWorkSample()
        {
           
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {
               
            }
            return WSample;

        }

        //删除工作样品
        //string sWorkSampleName : 删除工作样品名称
        public bool DeleteWorkSample(string sWorkSampleName)
        {
            return m_ProjDataMgr.DeleteSampleByName(sWorkSampleName);
        }

        // 获取样品总数
        //返回样品总数
        public int GetSampleCount()
        {
            return m_ProjDataMgr.GetSampleList().Count();
        }

        //改变工作样品名称
        //String sWSampleNewName
        public bool ChangeWorkSampleName(String sWSampleNewName)
        {
            if (!m_ProjDataMgr.IsValidSampleName(sWSampleNewName))
            {                
                return false;
            }
            COTSSample WorkSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WorkSample)
            {               
                return false;
            }

            WorkSample.SetName(sWSampleNewName);
            m_ProjDataMgr.SetModify(true);
            return true;

        }

        //移动工作样品到其他样品孔，样品孔名称和测量区域都要改变,重新设置工作样品参数
        //SampleMeasurePara SMeasurePara:
        public SampleMeasurePara SetWorkSampleHoleNameAndMeasureArea(SampleMeasurePara SMeasurePara)
        {
            SampleMeasurePara SMPara = new SampleMeasurePara();
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {                
                return SMPara;
            }

            CDomain Domain = new CDomain();
            Domain.SetShape((otsdataconst.DOMAIN_SHAPE)SMeasurePara.iShape);
            Domain.SetRectDomain(SMeasurePara.MeasureRect);
            if (SMeasurePara.DrawPolygonPointRegionF != null)
            {
                List<Point> PolygonPoint = new List<Point>();
                foreach (var item in SMeasurePara.DrawPolygonPointRegionF)
                {
                    PolygonPoint.Add(new Point((int)item.X, (int)item.Y));
                }
                Domain.SetPolygonPoint(PolygonPoint);
            }
            WSample.SetSampleHoleName(SMeasurePara.sHoleName);
            WSample.SetMsrArea(Domain);

            //获取样品的测量区域信息 
            SMPara.sSampleName = WSample.GetName();    //获取样品名称
            SMPara.iShape = (int)WSample.GetMsrArea().GetShape();  // 获取测量区域形状
            SMPara.sHoleName = WSample.GetSampleHoleName(); //获取样品孔名称
            SMPara.MeasureRect = (Rectangle)WSample.GetMsrArea().GetRectDomain();  //样品测量区域

            //改变测量区域后重新设置样品修改状态
            m_ProjDataMgr.SetModify(true);
            //string pathName = m_ProjDataMgr.GetPathName();
            //if (pathName != "" && pathName != "Untitled")
            //{
            //    m_ProjDataMgr.Save();
            //}
            return SMPara;

        }

        //获取图像尺寸参数
        //double iMag :   放大倍数
        //ref int iSFieldSize ：  返回的Field图片尺寸
        public void GetScanFieldSize(double iMag, ref int iSFieldSize)
        {
            CSEMDataMsr SemDataMsrClr = new CSEMDataMsr();
            SemDataMsrClr.SetScanFieldSize100(m_ProjDataMgr.GetSEMStageData().GetScanFieldSize100());
            SemDataMsrClr.SetMagnification(iMag);
            iSFieldSize = SemDataMsrClr.GetScanFieldSize();
        }


        //设置测量区域的形状 （通过RIBBON 上的画圆，画矩形 设置)
        //int iShape:  测量区域形状 0： 圆形； 1 ：矩形
        public void SetMeasureAreaShape(int iShape)
        {
            //  SampleMeasurePara SMPara = new SampleMeasurePara();
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
                return;
            }

            CDomain Domain = new CDomain();
            Domain.SetShape((otsdataconst.DOMAIN_SHAPE)iShape);
        }


        //修改了ITEMID后，重新更新GROUPID和ITEMID
        public void UpdateGroupValAndItemVal(OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS ItemID)
        {
            OTSDataType.OTS_SAMPLE_PROP_GRID_ITEM_GROUPS GroupID = OTSDataType.OTS_SAMPLE_PROP_GRID_ITEM_GROUPS.INVALID;
            OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS iItemID = OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS.INVALID;
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {
                return;
            }
            if (!WSample.GetRelatedPropItemGrp((OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS)ItemID, ref GroupID))
            {
                bool bFlag = WSample.GetRelatedPropItem(ItemID, ref iItemID);
            }

        }

        //当SampleSpaceWindow 获取电镜参数时，SampleSpaceWindow给MeasureApp发送事件通知MEASUREP更新电镜工作参数参数
        public bool UpdateSEMData()
        {
            //COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            //if (null == WSample)
            //{                
            //return false;
            //}
            //if (!WSample.SetPropItemGrps())
            //{              
            //return false;
            //}
            return true;
        }

        //设置样品参数锁
        //bool ParaLockFlag : 样品参数锁
        public bool SetSampleParaLock(bool ParaLockFlag)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {                
            return false;
            }
            WSample.SetParamLock(ParaLockFlag);
            m_ProjDataMgr.SetModify(true);
            return true;
        }

        //获取工作样品锁
        //ref bool ParamLockFlag : 获取的工作样品参数锁
        public bool GetWSampleParaLock(ref bool ParamLockFlag)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
            return false;
            }
            ParamLockFlag = WSample.GetParamLock();
            return true;
        }

        //获取工作样品测量锁
        public bool GetWSampleParaLock(ref OTSSampleMeaInfo SMInfo)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {                
            return false;
            }
           
            if (!GetWorkSamplePropertyVal(WSample, ref SMInfo))
            {
                
            return false;
            }
            return true;
        }

        //重新设置样品在样品列表中的位置（当拖动TREEVIEW的样品顺序后执行 ）
        public bool SortSamplePosition(List<string> SNameList)
        {
            if (!m_ProjDataMgr.ResetSamplesListOrder(SNameList))
            {                
             return false;
            }

            List<COTSSample> SampleList = new List<COTSSample>();
            SampleList = m_ProjDataMgr.GetSampleList();
            
            return true;
        }

        //打开保存的样品文件
        //List<CWorkSampleParam> SampleFileList  样品文件中的样品列表
        //成功返回 True;
        public bool OpenExistSampleFile(ref List<CTreeSampleParam> SampleMeasureInfoList)
        {
            int iSampleCount = m_ProjDataMgr.GetSampleList().Count();
            if (0 == iSampleCount)
            {               
            return false;
            }
            for (int i = 0; i < iSampleCount; i++)
            {
                CTreeSampleParam TSampleParam = new CTreeSampleParam();
                COTSSample SampleClr = (m_ProjDataMgr.GetSampleList())[i];
                GetExistSampleInfo(SampleClr, ref TSampleParam);
                SampleMeasureInfoList.Add(TSampleParam);
            }
            return true;
        }

        //获取样品的属性值
        //ref List<CTreeSampleParam> CTSampleParam :  打开已保存样品文件中的样品信息，用于TREEVIEW显示
        public void GetExistSampleInfo(COTSSample SampleClr, ref CTreeSampleParam CTSampleParam)
        {
            CTSampleParam.sSampleTitleName = m_ProjDataMgr.GetFileName();
            CTSampleParam.sWorkSampleName = SampleClr.GetName();
            CTSampleParam.bSwitch = SampleClr.GetSwitch();
            CTSampleParam.bParamLock = SampleClr.GetParamLock();

        }

        //打开保存的样品文件
        //List<SampleMeasurePara> SampleMeasureAreaList  样品文件中的样品列表,返回样品的测量区域给SampleSpaceWindow
        //成功返回 True;
        public bool OpenExistSampleMeasureArea(ref List<SampleMeasurePara> SampleMeasureAreaList)
        {
            int iSListCount = m_ProjDataMgr.GetSampleList().Count();
            if (0 == iSListCount)
            {
                return false;
            }
            for (int i = 0; i < iSListCount; i++)
            {
                SampleMeasurePara SampleMeasureArea = new SampleMeasurePara();
                //获取样品的测量区域信息 
                //获取样品名称
                SampleMeasureArea.sSampleName = (m_ProjDataMgr.GetSampleList())[i].GetName();
                // 获取测量区域形状
                SampleMeasureArea.iShape = (int)(m_ProjDataMgr.GetSampleList())[i].GetMsrArea().GetShape();
                //获取样品孔名称
                SampleMeasureArea.sHoleName = (m_ProjDataMgr.GetSampleList())[i].GetSampleHoleName();
                //样品测量区域
                SampleMeasureArea.MeasureRect = (Rectangle)(m_ProjDataMgr.GetSampleList())[i].GetMsrArea().GetRectDomain();
                //多边形点集合
                SampleMeasureArea.PolygonPointRegion = (m_ProjDataMgr.GetSampleList())[i].GetMsrArea().GetPolygonPoint();
                List<PointF> PointRegionF = new List<PointF>();
                List<Point> PolygonPoint = m_ProjDataMgr.GetSampleList()[i].GetMsrArea().GetPolygonPoint();
                if (PolygonPoint != null)
                {
                    foreach (var item in m_ProjDataMgr.GetSampleList()[i].GetMsrArea().GetPolygonPoint())
                    {
                        PointRegionF.Add(new PointF(item.X, item.Y));
                    }
                }
                SampleMeasureArea.PolygonPointRegionF = PointRegionF;
                SampleMeasureArea.DrawPolygonPointRegionF = PointRegionF;
                SampleMeasureAreaList.Add(SampleMeasureArea);
            }
            return true;
        }
    
        //检查样品测量参数
        //ref List<COTSSample> SampleList:  返回的检查参数的样品列表
        //bool bCheckFlag:   //	True，用户点击检查参数按钮  False ,在点击运行按钮 ；
        public bool CheckSampleParam(bool bCheckFlag)
        {
            m_MeasureSampleList.Clear();
            List<COTSSample> MSampleList = new List<COTSSample>();
            if (m_MsrThread == null)
            {
                InitMeasureThread();
            }
            if (!m_MsrThread.CheckMeasureParam(m_ProjDataMgr, ref MSampleList, bCheckFlag))
            {                
                return false;
            }
            if (MSampleList.Count > 0)
            {
                m_MeasureSampleList = MSampleList;
                return true;
            }
            return false;
        }

        //获取测量参数文件名称
        //int iNamePos:  文件名在链表中的位置
        //List<string> MParamFileNameList：  测量参数文件链表
        public bool GetMeasureParamFileName(ref int iNamePos, ref List<string> MParamFileNameList)
        {
            if (!m_ProjDataMgr.GetParamFileList(ref iNamePos, ref MParamFileNameList))
            {               
            return false;
            }
            return true;
        }
        //设置测量文件名称
        //int iNamePos:  文件名在链表中的位置
        public bool SetMeasrueParamFileName(int iNamePos)
        {
            if (!m_ProjDataMgr.ChangeParamFromList(iNamePos))
            {               
            return false;
            }
            return true;
        }

        //获取STD 标准库文件名称
        //int iNamePos:  文件名在链表中的位置
        //List<string> STDFileNameList：  STD文件链表
        public bool GetSTDFileName(ref int iNamePos, ref List<string> STDFileNameList)
        {
            if (!m_ProjDataMgr.GetSTDFileList(ref iNamePos, ref STDFileNameList))
            {               
            return false;
            }
            return true;
        }
        //设置STD 标准库文件名称
        public bool SetSTDFileName(int iNamePos)
        {
            if (!m_ProjDataMgr.ChangeSTDFromList(iNamePos))
            {               
            return false;
            }
            return true;
        }

        ///保存工作样品的测量参数文件     
        public bool SaveWorkMeasureFile()
        {
            CMsrParamFileMrg SMeasureParamData = new CMsrParamFileMrg();
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
            return false;
            }
            if (!SMeasureParamData.SetMsrParamFile(WSample.GetMsrParams()))
            {               
            return false;
            }
            SMeasureParamData.Save("");
            return true;
        }




        //打开工作样品的测量参数文件     
        public bool LoadWorkMeasureFile()
        {
            CMsrParamFileMrg SMeasureParamData = new CMsrParamFileMrg();

            if (!SMeasureParamData.Load("", true))
            {               
            return false;
            }

            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
            return false;
            }

            WSample.SetMsrParams(SMeasureParamData.GetMsrParams());

            //更新样品GRID值测量文件名
            OTSSampleMeaInfo SMInfo = new OTSSampleMeaInfo();
            if (!this.GetWorkSamplePropertyVal(WSample, ref SMInfo))
            {                
            return false;
            }
            m_MeasureAppFrom.m_SPropertyWindows.DisplaySampleMeasureInfo(SMInfo);
            return true;
        }

       

        //判断是否允许修改样品名
        public bool CheckSampleNameIsValid(string sNewName)
        {
            return m_ProjDataMgr.IsValidSampleName(sNewName);
        }

        //设置电镜参数
        //int iScanFieldSize: Field扫描参数
        //int iWDistance： 电镜工作距离
        //double dMagni： 放大倍数
        public void SetSEMData(double iWDistance, double dMagni)
        {
            try
            {
                m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().SetScanFieldSize100(m_ProjDataMgr.GetSEMStageData().GetScanFieldSize100());
                m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().SetWorkingDistance(iWDistance);
                m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().SetMagnification(dMagni);
            }
            catch (Exception)
            {
            }
        }

        //获取电镜参数
        //int iScanFieldSize: Field扫描参数
        //int iWDistance： 电镜工作距离
        //double dMagni： 放大倍数
        public void GetSEMData(ref double iWDistance, ref double dMagni)
        {
            iWDistance = m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetWorkingDistance();
            dMagni = m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetMagnification();
        }

        //获取工作样品的测量区域
        //int iShape :测量区域形状
        //Rectangle Srect: 测量区域大小
        public bool GetWSampleMrsArea(ref int iShape, ref Rectangle Srect)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {                
            return false;
            }

            CDomain pMsrArea = new CDomain();
            pMsrArea = WSample.GetMsrArea();
            if (null == pMsrArea)
            {
            return false;
            }

            iShape =(int) pMsrArea.GetShape();

            ValueType ValType = new Rectangle();
            ValType = pMsrArea.GetRectDomain();
            Srect = (Rectangle)ValType;
            return true;
        }

        //获取幁图数
        //ref List<Point> pField：  幁图数
        public bool GetField(ref List<Point> pFields, ref Size iSzie)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {              
            return false;
            }

            CDomain pMsrArea = new CDomain();
            pMsrArea = WSample.GetMsrArea();

            COTSImgScanPrm pImgScanParam = new COTSImgScanPrm();
            pImgScanParam = m_ProjDataMgr.GetImageScanParam();
            CSEMDataMsr pSEMDataMsr = new CSEMDataMsr();
            //设置参数
            pSEMDataMsr.SetMagnification(m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetMagnification());
            pSEMDataMsr.SetScanFieldSize(m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetScanFieldSize());
            pSEMDataMsr.SetScanFieldSize100(m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetScanFieldSize100());
            pSEMDataMsr.SetTotalFields(m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetTotalFields());
            pSEMDataMsr.SetWorkingDistance(m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().GetWorkingDistance());

            CFieldMgr pFieldMgr = new CFieldMgr();
            List<Point> listPoint = new List<Point>();
            listPoint.Clear();
            //设置测量区域
            CSEMDataMsr pSEMDataMsrTemp = pSEMDataMsr;
            if (m_MeasureAppFrom.m_MessageStates == (int)MessageState.ShootBSEPicture)
            {
                //获取最小放大倍数与FieldSize100倍数
                pSEMDataMsrTemp.SetScanFieldSize100(m_ProjDataMgr.GetSEMStageData().GetScanFieldSize100());
                double dMagnification = m_MeasureAppFrom.m_DataMgrFun.m_StageFile.GetStageData().GetMinMag();
                pSEMDataMsrTemp.SetMagnification(dMagnification);
                //设置样品孔当前位置信息
                Rectangle sampleHoleRect = (Rectangle)OTSMeasureThreadFun.c_DomainMessure.GetRectDomain();
                //判断
                if ((int)m_MeasureAppFrom.m_SamplepaceWindow.CMStrip.Items[9].Tag == 1)
                {
                    int shape = 0;
                    foreach (var item in OTSSamplespaceWindow.m_SampleHoleGDIObjects)
                    {
                        if (item.Name == WSample.GetName())
                        {
                            shape = item.Shape;
                        }
                    }
                    pMsrArea.SetShape((otsdataconst.DOMAIN_SHAPE)shape);
                }
                pMsrArea.SetRectDomain(sampleHoleRect);
                ////初始化
                if (!pFieldMgr.Init(pMsrArea, pImgScanParam, pSEMDataMsrTemp, listPoint))
                {
                    return false;
                }
            }
            else if (m_MeasureAppFrom.m_MessageStates == (int)MessageState.MeasureBSEPicture)
            {
                //获取最小放大倍数与FieldSize100倍数
                pSEMDataMsrTemp.SetScanFieldSize100(m_ProjDataMgr.GetSEMStageData().GetScanFieldSize100());
                double dMagnification = m_MeasureAppFrom.m_DataMgrFun.m_StageFile.GetStageData().GetMinMag();
                pSEMDataMsrTemp.SetMagnification(dMagnification);
                //设置样品孔当前位置信息
                Rectangle sampleHoleRect = (Rectangle)OTSMeasureThreadFun.c_DomainMessure.GetRectDomain();
                pMsrArea.SetRectDomain(sampleHoleRect);
                ////初始化
                if (!pFieldMgr.Init(pMsrArea, pImgScanParam, pSEMDataMsrTemp, listPoint))
                {
                    return false;
                }
            }
            else
            {
                try
                {
                    //设置当前工作区域
                    if (OTSMeasureThreadFun.c_DomainMessure != null)
                    {
                        Rectangle measureRect = (Rectangle)OTSMeasureThreadFun.c_DomainMessure.GetRectDomain();
                        pMsrArea.SetRectDomain(measureRect);
                    }
                }
                catch (Exception ex)
                {
                   log.Error("获取幁图数问题：" + ex.ToString());
                }
                ////初始化
                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 = ((Rectangle)oValue).Size;
            //将幁图数赋值给工作样品后
            m_ProjDataMgr.GetWorkingSample().GetSEMDataMsr().SetTotalFields(iFieldCount);
            return true;
        }

        //检查Samplelist中的sample的checkbox状态
        //当Samplelist中的链表有sample 的checkbox状态是选中状态，则返回TRUE. 说明可以测量
        public bool GetSampleCheckBoxStatus()
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
                return false;
            }
            List<COTSSample> SampleList = new List<COTSSample>();
            SampleList = m_ProjDataMgr.GetSampleList();
            int iCount = SampleList.Count();
            if (0 == iCount)
            {
                return false;
            }

            for (int i = 0; i < iCount; i++)
            {
                if (SampleList[i].GetSwitch())
                {
                    return true;
                }
            }

            return false;
        }

        //获取BSE图像数据
        public bool GetBSEImageSize(ref int iHeight, ref int iWidth)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
            return false;
            }

            if (!WSample.GetBSESize(out iHeight, out iWidth))
            {                
            return false;
            }
            return true;
        }

        //获取测量的BSE图
        //Byte[] BSEImage: 带背景图数据
        //int iHeight:  图像高度
        //int iWidth：  图像宽度
        //Byte[]BSEImageNoBG ： 去背景图数据
        public bool GetBSEImage(Byte[] BSEImage, int iHeight, int iWidth, ref Byte[] BSEImageNoBG)
        {
            CBSEImg pBSEImageIn = new CBSEImg();
            CBSEImg pBSEImageOut = new CBSEImg();

            Rectangle rect = new Rectangle();
            rect.Height = iHeight;
            rect.Width = iWidth;
            pBSEImageIn.SetImageRect(rect);
            pBSEImageIn.SetImageData(BSEImage, iHeight * iWidth);

            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
            return false;
            }

            COTSImgProcPrm ImgProcPrm = WSample.GetMsrParams().GetImageProcessParam();

            if (!m_ProjDataMgr.RemoveBackGround(pBSEImageIn, ImgProcPrm, ref pBSEImageOut))
            {
            return false;
            }

            BSEImageNoBG = pBSEImageOut.GetImageDataPtr();

            return true;
        }
        
        /// <summary>
        /// 获取测量的BSE图
        /// </summary>
        /// <param name="BSEImage">BSE原数据</param>
        /// <param name="iHeight">图像高度</param>
        /// <param name="iWidth">图像宽度</param>
        /// <param name="grayStart"></param>
        /// <param name="grayEnd"></param>
        /// <param name="BSEImageNoBG">去背景图数据</param>
        /// <returns></returns>
        public bool GetBSEImage(Byte[] BSEImage, int iHeight, int iWidth,int grayStart,int grayEnd, ref Byte[] BSEImageNoBG)
        {
            CBSEImg pBSEImageIn = new CBSEImg();
            CBSEImg pBSEImageOut = new CBSEImg();

            Rectangle rect = new Rectangle();
            rect.Height = iHeight;
            rect.Width = iWidth;
            pBSEImageIn.SetImageRect(rect);
            pBSEImageIn.SetImageData(BSEImage, iHeight * iWidth);

            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {
                return false;
            }

            COTSImgProcPrm ImgProcPrm = WSample.GetMsrParams().GetImageProcessParam();
            CIntRange cIntRangeClr = new CIntRange();
            cIntRangeClr.SetStart(grayStart);
            cIntRangeClr.SetEnd(grayEnd);
            ImgProcPrm.SetBGGray(cIntRangeClr);

            if (!m_ProjDataMgr.RemoveBackGround(pBSEImageIn, ImgProcPrm, ref pBSEImageOut))
            {
                return false;
            }

            BSEImageNoBG = pBSEImageOut.GetImageDataPtr();

            return true;
        }

        //获取图像尺寸
        public string GetBSEImageSize()
        {
            try
            {
                COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
                if (null == WSample)
                {                    
                return "";
                }

                OTSSampleMeaInfo SMInfo = new OTSSampleMeaInfo();
                if (!GetWorkSamplePropertyVal(WSample, ref SMInfo))
                {                   
                return "";
                }
                int iCount = SMInfo.SampleDataList.Count();
                for (int i = 0; i < iCount; i++)
                {
                    if (OTS_SAMPLE_PROP_GRID_ITEMS.IMAGE_RESOLUTION == SMInfo.SampleDataList[i].iSampleId)
                    {
                       
                        String val= (String)SMInfo.SampleDataList[i].SampleVal;

                        return val;
                    }
                }
                return "";
            }
            catch (Exception)
            {
                return "";
            }
        }

        //获取放大倍数和工作距离
        public bool GetMagAndDistance(ref double SemMag, ref double dDistance)
        {
            try
            {
                COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
                if (null == WSample)
                {                   
                return false;
                }

                OTSSampleMeaInfo SMeasureInfo = new OTSSampleMeaInfo();

                if (!GetWorkSamplePropertyVal(WSample, ref SMeasureInfo))
                {
                return false;
                }

                int iCount = SMeasureInfo.SampleDataList.Count;
                if (iCount == 0)
                {                    
                return false;
                }

                bool iFlag = false;
                for (int i = 0; i < iCount; i++)
                {
                    if (SMeasureInfo.SampleDataList[i].iSampleId == OTS_SAMPLE_PROP_GRID_ITEMS.MAGNIFICATION)
                    {
                        SemMag = Convert.ToDouble(SMeasureInfo.SampleDataList[i].SampleVal);
                        iFlag = true;
                    }
                    if (SMeasureInfo.SampleDataList[i].iSampleId == OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE)
                    {
                        dDistance = Convert.ToDouble(SMeasureInfo.SampleDataList[i].SampleVal);
                        iFlag = true;
                    }
                }
                if (iFlag)
                {
                return true;
                }
                return false;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public bool GetWorkSamplePropertyVal(COTSSample Sample, ref OTSSampleMeaInfo SMeasureInfo)
        {
            //设置工作样品属性项
            Sample.SetPropItemGrps();
            bool MeasurementStatus = false;
            if (null == Sample)
            {
                return false;
            }

            //样品的标题名 (Treeview的根节点名)           
            SMeasureInfo.sSampleSoluName = m_ProjDataMgr.GetFileName();

            // Treeview 的样品信息  
            SMeasureInfo.TSampleParam.sSampleTitleName = m_ProjDataMgr.GetFileName();

            //获得 样品属性值

            //JObject jo = Sample.GetJSONProperty();

            SMeasureInfo.bSwitch = Sample.GetSwitch();// (bool)jo.GetValue("bSwitch");
            SMeasureInfo.TSampleParam.bParamLock = Sample.GetParamLock();// (bool)jo.GetValue("ParamLock");

            //获取样品的测量区域信息 
            //获取样品名称
            //JObject SMeasurePara = (JObject)jo.GetValue("SMeasurePara");
            SMeasureInfo.SMeasurePara.sSampleName = Sample.GetName();// (String)SMeasurePara.GetValue("sNewSampleName");
            // 获取测量区域形状
            SMeasureInfo.SMeasurePara.iShape =(int) Sample.GetMsrArea().GetShape();// (int)SMeasurePara.GetValue("iShape");
            //获取样品孔名称
            SMeasureInfo.SMeasurePara.sHoleName = Sample.GetSampleHoleName();// (String)SMeasurePara.GetValue("sHoleName");
                                                                             //样品测量区域
                                                                             // JObject rec = (JObject)SMeasurePara.GetValue("MeasureRect");
            Rectangle rec = Sample.GetMsrArea().GetDomainRect();
            SMeasureInfo.SMeasurePara.MeasureRect = new Rectangle((int)rec.X, (int)rec.Y , (int)rec.Width, (int)rec.Height);

            // JObject TSampleParam = (JObject)jo.GetValue("TSampleParam");
            SMeasureInfo.TSampleParam.sWorkSampleName = Sample.GetName();// (String)TSampleParam.GetValue("sWorkSampleName");
            SMeasureInfo.TSampleParam.bSwitch = Sample.GetSwitch();// (bool)TSampleParam.GetValue("bSwitch");

           List< CPropItemGrp> ja = Sample.GetPropItemGrps();// (JArray)jo.GetValue("ItemGrp");

            for (int i = 0; i < ja.Count; i++)
            {
                //获取GROUP ID和Grid的显示组的标题名
                var grp = ja[i];
                int grpId = (int)grp.GetGroupId();
                String sTitle = (String)grp.GetName();

                //获取样品属性ID和值

                var SDataArr = grp.GetItemsList();
                if (SDataArr.Count == 0)
                    continue;

                SampleDataGroup smlgrp = new SampleDataGroup();
                smlgrp.GroupId = (OTS_SAMPLE_PROP_GRID_ITEM_GROUPS)grpId;
                smlgrp.sTitle = sTitle;
                for (int j = 0; j < SDataArr.Count; j++)
                {
                    var SDataObj = SDataArr[j];
                    SampleData SData = new SampleData();
                    int smplid = (int)SDataObj.GetSmplItemId();
                    SData.iSampleId = (OTS_SAMPLE_PROP_GRID_ITEMS)smplid;
                    if (SData.iSampleId == OTS_SAMPLE_PROP_GRID_ITEMS.WORKING_DISTANCE)
                    {
                        bool b = (bool)SDataObj.IsReadOnly();
                    }
                    SData.sSCaptionName = (String)SDataObj.GetName();
                    //------------------------------修改--------------------------

                    if ((String)SDataObj.GetName() == "样品名")
                    {
                        for (int a = 0; a < ja.Count; a++)
                        {
                            var grpa = ja[a];
                            var SDataArra = grpa.GetItemsList();
                            for (int b = 0; b < SDataArra.Count; b++)
                            {
                                var SDataObb = SDataArra[b];
                                if ((String)SDataObb.GetName() == "测量状态")
                                {
                                    if ((String)Sample.GetItemValueStr((OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS)SDataObb.GetSmplItemId()) == "未测量")
                                    {
                                        MeasurementStatus = false;
                                    }
                                    else
                                    {
                                        MeasurementStatus = true;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        MeasurementStatus = false;
                    }
                    if (MeasurementStatus)
                    {
                        SData.bReadOnly = MeasurementStatus;
                    }
                    else
                    {
                        SData.bReadOnly = (bool)SDataObj.IsReadOnly();// OTS_ITEM_TYPES
                    }

                    //---------------------------------------------------------------

                    //SData.bReadOnly = (bool)SDataObj.GetValue("IsReadOnly");// OTS_ITEM_TYPES
                    int type = (int)SDataObj.GetTypeId();
                    SData.iSampleValType = (OTS_ITEM_TYPES)type;
                    SData.sDescriptionInfo = (String)SDataObj.GetDescription();
                    //SData.SampleVal = (String)SDataObj.GetItemValueStr();
                    OTSDataType.OTS_SAMPLE_PROP_GRID_ITEMS ItemId = SDataObj.GetSmplItemId();
                    SData.SampleVal = (String)Sample.GetItemValueStr(ItemId);
                    List<string> downStrList = new List<string>();
                    if (type == (int)OTS_ITEM_TYPES.COMBO)
                    {
                        Sample.GetPropComboStrings( SDataObj.GetSmplItemId(),downStrList);
                    }
                    else if (type == (int)OTS_ITEM_TYPES.FILE_LIST)
                    {
                        //the sample object dosen't know anything about the fileList infomation so it has to delay this duty here.
                        int iPos = -1;
                        List<string> sFileNameList = new List<string>();
                        if (OTS_SAMPLE_PROP_GRID_ITEMS.MEASURE_PARAM_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)smplid)
                        {
                            if (!this.GetMeasureParamFileName(ref iPos, ref sFileNameList))
                            {
                                return false;
                            }
                            foreach (var f in sFileNameList)
                            {
                                downStrList.Add(f);
                            }

                        }

                        if (OTS_SAMPLE_PROP_GRID_ITEMS.STD_FILE_NAME == (OTS_SAMPLE_PROP_GRID_ITEMS)smplid)
                        {
                            if (!this.GetSTDFileName(ref iPos, ref sFileNameList))
                            {
                                return false;
                            }
                            foreach (var f in sFileNameList)
                            {
                                downStrList.Add(f);
                            }

                        }

                    }

                    if (downStrList.Count > 0)
                    {
                        for (int k = 0; k < downStrList.Count; k++)
                        {
                            SData.comboDownList.Add((String)downStrList[k]);
                        }
                    }
                    smlgrp.SampleDataList.Add(SData);

                }
                SMeasureInfo.AddASampleDataGrp(smlgrp);
            }

            return true;
        }

        //  样品测量功能
        public void InitMeasureThread()
        {
            if (m_MsrThread == null)
            {
                m_MsrThread = new CMsrThread();

                m_MsrThread.Init(m_ProjDataMgr);
            }
               

                m_MsrThread.GetMeasureAppFormName(m_MeasureAppFrom.Text  );//set appName to underlying c++ program.

          
           

        }

        //初始化测量样品
        public bool InitMeasureSample()
        {

            m_MsrThread.Init(m_ProjDataMgr);
          
            m_MsrThread.GetMeasureAppFormName(m_MeasureAppFrom.Name );//set appName to underlying c++ program.
            return true;
        }
        public bool InitHolePreview()
        {
            if (!m_MsrThread.Init(m_ProjDataMgr, m_ProjDataMgr.GetSampleList()))
            {               
            return false;
            }
            m_MsrThread.GetMeasureAppFormName(m_MeasureAppFrom.Name );
            return true;
        }
      
        // 开始获取样品孔中的照片
        public void DoHolePreview(int m_HoleID, CDomain c_DomainMessure)
        {
            m_MsrThread.DoHolePreview(m_HoleID, c_DomainMessure);
        }
        // 开始样品测量
        public void DoMeasure()
        {
            m_MsrThread.DoMeasure();
        }

        //停止测量
        public void SetMeasureThreadStatus(MSR_THREAD_STATUS ThreadStatus)
        {
            //设置测量线程状态
            m_MsrThread.SetMsrLoopStatus((otsdataconst.OTS_MSR_THREAD_STATUS)ThreadStatus);
        }

        //保存测量样品的
        public bool SaveMeasureSampleInfo()
        {
            m_ProjDataMgr = GetNewProjMgr();
            if (null == m_ProjDataMgr)
            {               
            return false;
            }
            log.Trace(" m_ProjDataMgr.GetSampleList().Count = " + m_ProjDataMgr.GetSampleList().Count.ToString());
            if (!m_ProjDataMgr.Save())
            {
            return false;
            }
            return true;
        }
     
        //获取测量Sample的开始时间
        public bool GetMsrSampleStartTime(ref DateTime MsrFieldStartTime)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {              
            return false;
            }
            MsrFieldStartTime = (DateTime)WSample.GetMsrStatus().GetStartTime();
            return true;
        }

        //获取测量已用时间
        public bool GetMsrSampleUsedTime(ref TimeSpan TUsedTime)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {                
            return false;
            }
            TUsedTime = (TimeSpan)WSample.GetMsrStatus().GetUsedTime();
            return true;
        }

     
        //获取新的工作文件对象
        public COTSProjMgrFile GetNewProjMgr()
        {
            if (null == m_MsrThread)
            {                
            return null; ;
            }
            return m_MsrThread.GetProjMgrFile();
        }

        // 获取测量结果信息
        public bool GetMsrRetData(ref SMSR_COMPLETE_DATA MsrCompleteData)
        {
            try
            {
                COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
                if (null == WSample)
                {                    
                return false;
                }

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

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

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

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

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

                MsrCompleteData.iMsrCompleteSampleCount = MeasureCompleteSampleList.Count();

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

                return true;
            }
            catch (Exception ex)
            {
               log.Error("(OTSDataMgrFun.GetMsrRetData) Exception:"+ex.ToString());
                return false;
            }
        }


        // 获取测量样品中之前已经测量完成Field帧图，（上一次未测量完成继续测试）
        public bool GetBeforeCompleteField(ref string MsrSampleName, ref List<Point> FieldList)
        {
            COTSSample WSample = m_ProjDataMgr.GetWorkingSample();
            if (null == WSample)
            {               
            return false;
            }

            MsrSampleName = WSample.GetName();            
            FieldList = WSample.GetMsrStatus().GetCpltedCenter();
            return true;
        }
      
     
        // 当TREEVIEW 的样品参数锁状态发生变化后，Solution 需要将样品参数锁状态发送给MeasureApp更新新的样品参数锁状态
        // string sSampleName :  样品参数锁对应的样品名
        //bool bParaLockFlag:  样品新的排列顺序；
        public bool SetSampleLockPara(string sSampleName, bool bFlag)
        {          
            return true;
        }
           
        /// <summary>
        /// 通过样品孔信息 返回默认测量区域大小
        /// </summary>
        /// <param name="cHoleClr"></param>
        /// <returns></returns>
        public Rectangle CalculateMsrArea(string cHoleName)
        {
            CHole cHoleClr = null;
            foreach (CHole item in m_ProjDataMgr.GetStage().GetHoleList())
            {
                if (item.GetName() == cHoleName)
                {
                    cHoleClr = item;
                }
            }
            CDomain CDomain = m_ProjDataMgr.CalculateMsrArea(cHoleClr);
            return (Rectangle)CDomain.GetRectDomain();
        }

        /// <summary>
        /// 获取已完成测量的结果文件路径
        /// </summary>
        /// <param name="mrFilePathList">返回测量结果文件路径</param>
        /// <returns></returns>
        public bool GetCompletedMeasureFileName(ref List<string> mrFilePathList)
        {
            //测量文件路径
            string proFilePath = m_ProjDataMgr.GetPathName();
            //样品列表
            List<COTSSample> sampleList = m_ProjDataMgr.GetSampleList();
            //获取样品数量
            int sampleCount = sampleList.Count;
            string mrSuffix = ".rst";
            int existsCount = 0;
            //获取测量文件路径
            if (proFilePath.Equals("Untitled"))
            {
                return false;
            }
            string mrFolderPath = string.Empty;
            try
            {
                mrFolderPath = proFilePath.Substring(0, proFilePath.LastIndexOf("\\"));
            }
            catch (Exception)
            {
                mrFolderPath = string.Empty;
            }
            for (int sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++)
            {
                int CompleteFieldsCount=sampleList[sampleIndex].GetMsrStatus().GetCompletedFields();
                //如果样品已测量成功后再加载至报告程序中
                if (CompleteFieldsCount > 0)
                {
                    string sampleName = sampleList[sampleIndex].GetName();
                    string mrFilePath = mrFolderPath + "\\" + sampleName + "\\" + sampleName + mrSuffix;
                    //判断文件是否存在
                    if (File.Exists(mrFilePath))
                    {
                        if (mrFilePathList != null)
                        {
                            mrFilePathList.Add(mrFilePath);
                        }
                        existsCount++;
                    }
                }
            }
            if (existsCount > 0)
            {
                return true;
            }
            return false;
        }

        internal bool ReClassify()
        {
            if (m_ProjDataMgr != null)
            {
                return m_ProjDataMgr.ReClassify();
            }

            return false;
        }

        /// <summary>
        /// 获取工作样品的测量状态
        /// </summary>
        /// <param name="workingSampleName"></param>
        /// <returns></returns>
        public bool GetWorkSampleMeasureStatus()
        {
            bool reuslt = false;
            COTSSample COTSSample = m_ProjDataMgr.GetWorkingSample();
            int sampleStatus = COTSSample.GetMsrStatus().GetCompletedFields();
            if (sampleStatus > 0)
            {
                reuslt = true;
            }
            return reuslt;

         }
    }

    public class OTSBSEImageFun 
    {       
        OTSIncAMeasureAppForm m_MsrApp = null;
        NLog.Logger log = NLog.LogManager.GetCurrentClassLogger();
        public OTSBSEImageFun(OTSIncAMeasureAppForm MsrApp)
        {
            m_MsrApp = MsrApp;            
        }

        public int GetScanImage(int iWidth, int iHeigh, ref byte[] bImageData)
        {
            //电镜设置对象
            COTSControlFunExport cfun = new COTSControlFunExport();
            int GetImgCount = 0;
            try
            {
                //连接电镜
                bool IsConnec = cfun.ConncetSem();
                if (!IsConnec)
                {
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.ConncetSem() = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
                //实例电镜初始化
                bool IsScan = cfun.ScanInit();
                if (!IsScan)
                {
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.ScanInit = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
               
                int a_ExternalMode = 0;
                //获取终止模式
              
                a_ExternalMode = cfun.GetSemExternalMode();
                
                //保存初始模式变量
                int a_oldMode = 0;
                //获取初始模式
               
                if (!cfun.GetSemScanMode(ref a_oldMode))
                {
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.GetSemScanMode = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
               
                //设置当前模式
               
                if (!cfun.SetSemScanMode(a_ExternalMode))
                {
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.SetSemScanMode = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
                

                #region BeamBlank
                int a_nBeamBlank = 0;
                //获取参数
             
                if (!cfun.GetSemBeamBlank(ref a_nBeamBlank))
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.GetSemBeamBlank = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
               
                //设置参数               
                if (!cfun.SetSemBeamBlank(0))
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.SetSemBeamBlank = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
               
                #endregion

                #region 获得放大倍数
                //获得放大倍数
                double a_dMagnification = 0;
              
                //获取参数
                if (!cfun.GetSemMagnification(ref a_dMagnification))
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.GetSemMagnification = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
              
                #endregion

                #region 获取 电镜 X、Y轴 与角度
                //获取 电镜 X、Y轴 与角度
                double PositionX = 0;
                double PositionY = 0;
                double PositionR = 0;
                //获取参数
                
                if (!cfun.GetSemPositionXY(ref PositionX, ref PositionY, ref PositionR))
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.GetSemPositionXY = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
               
                #endregion

                #region 设置图像分辨率
                //设置宽度
               
                if (!cfun.SetImageSize(iWidth))
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.SetImageSize = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
               
                #endregion

                #region 采集时间
                //采集时间
                int nDwellTime = 4;
               
                if (!cfun.SetDwellTime(nDwellTime))
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.SetDwellTime = false  Failed";
                    log.Error(strErrorInfo);
                    return 0;
                }
                
                #endregion

                #region MatrixSize
                //获得放大倍数
                int a_MatrixSize = 0;
                Size size = new Size();
                //获取参数
                size = cfun.GetMatrixSize(a_MatrixSize);
                
                size = cfun.GetMatrixSize(a_MatrixSize);
              
                #endregion

                //获取图像数据

                int resultCount = iWidth * iHeigh;
              
                GetImgCount = cfun.AcquireBSEImage(0, 0, 0, ref bImageData);
                //记录日志
               
                if (resultCount == GetImgCount)
                {
                    //设置为原始 扫描模式
                  
                    cfun.SetSemScanMode(a_oldMode);
                    
                    //Scan类结束

                    //初始化电镜参数
                   
                    if (!cfun.SetAndStartScan())
                    {
                        return 0;
                    }
                   
                }
                else
                {
                    cfun.SetSemScanMode(a_oldMode);
                    string strErrorInfo = "(OTSBSEImageFun.GetScanImage) cfun.AcquireBSEImage = 0  Failed";
                    log.Error(strErrorInfo);
                   
                    //初始化电镜参数                  
                    if (!cfun.SetAndStartScan())
                    {
                        return 0;
                    }
                   
                }              
            }
            catch (Exception ex)
            {
                //记录日志
                log.Error(ex.Message.ToString());
                string strErrorInfo = "(OTSBSEImageFun.GetScanImage) Exception   Error Happend";
                log.Error(strErrorInfo);

            }
            finally
            {
                cfun.ScanFinishedInstance();
                cfun.DisConnectSem();
                cfun.FreeDll();
            }

            return GetImgCount;
        }
        
    }



}