OTS/OTS/OTSIncAMeasureApp/OTSProgMgrInfo/OTSProgMgrInfoFunction/OTSProgMgrInfoFun.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using OTSPeriodicTable;
//
using OTSProgMgrInfo.OTSProgMgrInfoFunction;

//using NSLogFunExport;
using OTSDataType;
using OTSModelSharp;
using OTSModelSharp.Measure.GetStageInfo;

namespace OTSProgMgrInfo.OTSProgMgrInfoFunction
{
    #region 枚举
    /// <summary>
    /// x轴方向选择列表
    /// </summary>
    enum OTS_X_AXIS_DIRECTION
    {
        //INVALID = -1,
        LEFT_TOWARD = 0,
        RIGHT_TOWARD = 1,
        //MIN = 0,
        //MAX = 1,
    }
    //enum OTS_X_AXIS_DIRECTION
    //{
    //    无效 = -1,
    //    向左 = 0,
    //    向右 = 1,
    //    //MIN = 0,
    //    //MAX = 1,
    //}

    /// <summary>
    /// y轴方向选择列表
    /// </summary>
    enum OTS_Y_AXIS_DIRECTION
    {
        //INVALID = -1,
        UP_TOWARD = 0,
        DOWN_TOWARD = 1,
        //MIN = 0,
        //MAX = 1,
    }
    //enum OTS_Y_AXIS_DIRECTION
    //{
    //    无效 = -1,
    //    向上 = 0,
    //    向下 = 1,
    //    //MIN = 0,
    //    //MAX = 1,
    //}

    /// <summary>
    /// 测量终止方式列表
    /// </summary>
    enum OTS_MEASURE_STOP_MODE
    {
        //INVALID = -1,
        //MIN = 0,
        CoverMode = 0,
        FieldMode = 1,
        ParticleMode = 2,
        TimeMode = 3,
        //MAX = 3
    }
    //enum OTS_MEASURE_STOP_MODE
    //{
    //    无效 = -1,
    //    //MIN = 0,
    //    转换模式 = 0,
    //    区域模式 = 1,
    //    颗粒模式 = 2,
    //    时间模式 = 3,
    //    //MAX = 3
    //}

    /// <summary>
    /// 取图方式列表
    /// </summary>
    enum OTS_GET_IMAGE_MODE
    {
        //INVALID = -1,
        // MIN = 0,
        FROM_CENTER = 0,
        UP_TO_DOWN = 1,
        DOWN_TO_UP = 2,
        RANDOM = 3,
        //MAX = 3
    }
    //enum OTS_GET_IMAGE_MODE
    //{
    //    无效 = -1,
    //    // MIN = 0,
    //    从中间 = 0,
    //    从上到下 = 1,
    //    从下到上 = 2,
    //    随机 = 3,
    //    //MAX = 3
    //}



    /// <summary>
    /// 扫描图精度列表列表等使用
    /// </summary>
    enum OTS_THREE_TIES_OPTIONS
    {
        //INVALID = -1,
        //MIN = 0,
        TIE1 = 0,
        TIE2 = 1,
        TIE3 = 2,
        //MAX = 2
    }

    /// <summary>
    /// X-ray扫描方式
    /// </summary>
    enum OTS_X_RAY_SCAN_MODE
    {
        //INVALID = -1,
		//MIN = 0,
		PointMode = 0,
		FeatureMode = 1,
		//MAX = 1
	}
//enum OTS_THREE_TIES_OPTIONS
//{
//    //无效 = -1,
//    //MIN = 0,
//    扫描方式1 = 0,
//    扫描方式2 = 1,
//    扫描方式3 = 2,
//    //MAX = 2
//}

/// <summary>
/// 扫描图尺寸列表
/// </summary>
enum OTS_FIVE_TIES_OPTIONS
    {
        //INVALID = -1,
        //MIN = 0,
        TIE1 = 0,
        TIE2 = 1,
        TIE3 = 2,
        TIE4 = 3,
        TIE5 = 4,
        //MAX = 4
    }

    /// <summary>
    /// 当前选择标准库下拉选项
    /// </summary>
    enum OTS_STDLIB_SELECT_OPTIONS
    {
        SySSTDData1 = 0,
        GeneralSTDData = 1,
        GeneralAlloySteelSTDData = 2,
        SpringSteelSTDSata = 3,
        用户定义标准库 = 4,
    }

    /// <summary>
    /// 精炼工艺下拉选项
    /// </summary>
    enum OTS_TECHNOLOGY_OPTIONS
    {
        通用方法 = 0,
        镁处理 = 1,
        钙处理 = 2,
        稀土处理 = 3
    }

    enum MEASURE_SHAPE
    {
        //INVALID = -1,
        //MIN = 0,
        CIRCLE = 0,
        RECT = 1,
        //MAX = 1
    }
    //enum OTS_FIVE_TIES_OPTIONS
    //{
    //    无效 = -1,
    //    //MIN = 0,
    //    方式1 = 0,
    //    方式2 = 1,
    //    方式3 = 2,
    //    方式4 = 3,
    //    方式5 = 4,
    //    //MAX = 4
    //}

    //enum OTS_X_RAY_SCAN_MODE
    //{
    //    无效 = -1,
    //    //MIN = 0,
    //    点模式 = 0,
    //    特征模式 = 1,
    //    //MAX = 1
    //}

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

    /// <summary>
    /// 模式选择下拉选项
    /// </summary>
    enum OTS_Model
    {
        ProfessionalMode = 0,             //专家模式
        NormalMode = 1,            //普通模式
    };

    /// <summary>
    /// 帧结束方式
    /// </summary>
    enum OTS_FrameEndMode
    {
        FieldParticlePercentage = 0,             //颗粒百分比
        ParticleNumber = 1,            //颗粒数量
    };

    /// <summary>
    /// 背景处理方式
    /// </summary>
    enum OTS_AUTOBGREMOVETYPE
    {
        AUTO = 0,
        MANUAL = 1,
    };

    /// <summary>
    /// 自动
    /// </summary>
    enum OTS_IMAGE_MODE
    {
        MIDDLE = 0,
        DOWNWARD = 1,
        UPWARD = 2,
    };
    #endregion

    #region ComboBox选择项类
    /// <summary>
    /// combobox控件，选择项对应类
    /// </summary>
    public class ComboBoxItem
    {
        private string _text = null;
        private object _value = null;
        public string Text { get { return this._text; } set { this._text = value; } }
        public object Value { get { return this._value; } set { this._value = value; } }
        public override string ToString()
        {
            return this._text;
        }
    }
    #endregion

    public class OTSProgMgrInfoFun 
    {
        #region 定义变量
        ProgMgrInfoForm PMIF;
        public CStage m_cstageclr;                                      //样品台类
        public CStageFile m_cstagefileclr;                              //样品台文件类
        public COTSProgMgr m_cotsprogmgrclr;                            //从这里开始load
        public COTSProgMgrParamFile m_cotsprogmgrparamfileclr;          //参数类
        //
        public CSEMStageData m_csemstagedataclr;                        //SEM样品台处理类
        public COTSImgScanPrm m_cotsimgscanprmclr;                      //图像扫描类
        public COTSGeneralParameters m_cgenparamclr;                                //一般参数类
        public COTSImageProcessParam m_cotsimgprocprmclr;                      //图像处理类
        public COTSXRayParam m_cotsxrayprmclr;                            //X-Ray类

        //后加
        //public CPartSTDFileMnrClr m_cpartstdfilemnrclr;                    //STD文件类
       // public CPartSTDDataClr m_cpartstddataclr;                               //std类 用这个类先定义一个文件，然后再进行操作

        public CMsrParamFileMrg m_cmsrparamfilemrgclr;                       //参数文件类

        // 初始化日志类
        //public CFunExportClass m_LogFunExport = null;                           //日志类
        public static NLog.Logger loger = NLog.LogManager.GetCurrentClassLogger();

        const String m_csFileName = "OTSMeasureAppLog";                         // 测量程序日志文件名
        #endregion

        #region 构造函数
        public OTSProgMgrInfoFun(ProgMgrInfoForm in_PMIF)
        {
            m_cotsprogmgrparamfileclr = new COTSProgMgrParamFile();
            //m_LogFunExport = new CFunExportClass();
            //m_LogFunExport.InitLog(m_csFileName);
            //loger.Trace(m_csFileName);

            m_cstageclr = new CStage();
            m_cstagefileclr = new CStageFile();
            m_cotsprogmgrclr = new COTSProgMgr();

            //初始化
           // m_cpartstddataclr = new CPartSTDDataClr();
            m_cmsrparamfilemrgclr = new CMsrParamFileMrg();

            PMIF = in_PMIF;
        }
        #endregion

        #region 样品台相关方法封装
        /// <summary>
        /// 样品台加载
        /// </summary>
        /// <returns></returns>
        public bool StageLoad()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.StageLoad)  加载样品台信息");

            if (!m_cstagefileclr.Load((int)OTS_SOFT_PACKAGE_ID.OTSIncA, true, !PMIF.m_b_checkstagefile))
            {
                //loger.Error("(OTSProgMgrInfoFun.StageLoad)  加载样品台信息失败");
                loger.Error("(OTSProgMgrInfoFun.StageLoad)  加载样品台信息失败");
                return false;
            }

            return true;
        }

        /// <summary>
        /// 获取正在工作的样品台类
        /// </summary>
        /// <returns></returns>
        public CStage GetWorkingStage()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.GetWorkingStage)  获取正在工作的样品台类");

            CStage ls_cstageclr = m_cstagefileclr.GetWorkingStage();
            if (null == ls_cstageclr)
            {
                //loger.Error("(OTSProgMgrInfoFun.GetWorkingStage)  获取正在工作的样品台类失败");
                loger.Error("(OTSProgMgrInfoFun.GetWorkingStage)  获取正在工作的样品台类失败");
                return ls_cstageclr;
            }

            return ls_cstageclr;
        }

        /// <summary>
        /// 获取正在工作的样品台ID
        /// </summary>
        /// <returns></returns>
        public int GetWorkingStageId()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.GetWorkingStageId)  获取正在工作的样品台ID");

            int stageid = m_cstagefileclr.GetWorkingStageId();

            return stageid;
        }

        /// <summary>
        /// 判断当前样品台是否在被修改
        /// </summary>
        /// <returns></returns>
        public bool IsModified()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.IsModified)  判断当前样品台是否在被修改");

            return m_cstagefileclr.IsModified();
        }

        /// <summary>
        /// 样品台保存
        /// </summary>
        /// <returns></returns>
        public bool StageSave()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.StageSave)  保存样品台信息");
            if (!m_cstagefileclr.Save((int)OTS_SOFT_PACKAGE_ID.OTSIncA))
            {
                //loger.Error("(OTSProgMgrInfoFun.StageLoad)  保存样品台信息失败");
                loger.Error("(OTSProgMgrInfoFun.StageLoad)  保存样品台信息失败");
                return false;
            }
            return true;
        }

        /// <summary>
        /// 获取样品台信息列表
        /// </summary>
        /// <returns></returns>
        public List<CStage> GetStageList()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.GetStageList)  获取样品台信息列表");
            List<CStage> l_cstageclr = m_cstagefileclr.GetStagesList();
            if (null == l_cstageclr)
            {
                //loger.Error("(OTSProgMgrInfoFun.GetStageList)  获取样品台信息列表失败");
                loger.Error("(OTSProgMgrInfoFun.GetStageList)  获取样品台信息列表失败");
                return l_cstageclr;
            }
            return l_cstageclr;
        }

        /// <summary>
        /// 通过id设置当前正在工作的样品台
        /// </summary>
        /// <param name="id"></param>
        public void SetWorkingStageId(int id)
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.SetWorkingStageId)  设置工作样品台，ID是:" + id.ToString());
            m_cstagefileclr.SetWorkingStageId(id);
        }

        /// <summary>
        /// 设置当前样品台正在被修改中
        /// </summary>
        /// <param name="yn"></param>
        public void SetModify(bool yn)
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.SetModify)  设置当前工作样修改标识为:"+yn.ToString() );
            m_cstagefileclr.SetModify(true);
        }

        /// <summary>
        /// 读取样品台参数信息
        /// </summary>
        public void LoadStageData()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.LoadStageData)  读取样品台参数信息" );
        }
        #endregion

        #region 参数相关方法封装
        /// <summary>
        /// 读取SEM样品台参数信息
        /// </summary>
        public void LoadSEMStageData()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.LoadSEMStageData)  读取样品台SEM参数信息");
            loger.Trace("(OTSProgMgrInfoFun.LoadSEMStageData)  读取样品台SEM参数信息");
            //100倍时屏幕尺寸/mm
            PMIF.IDC_EDIT_SCREENWIDTH.Text = m_csemstagedataclr.GetScanFieldSize100().ToString();
            //x轴方向
            //PMIF.IDC_COMBO_XDIREC.Text = ((OTS_X_AXIS_DIRECTION)Enum.ToObject(typeof(OTS_X_AXIS_DIRECTION), PMIF.m_csemstagedataclr.GetXAxisDir())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_XDIREC.Items)
            {
                if (cbi.Value.ToString() != "")
                if (Convert.ToInt32( cbi.Value) == Convert.ToInt32(m_csemstagedataclr.GetXAxisDir()))
                {
                        PMIF.IDC_COMBO_XDIREC.SelectedItem = cbi;
                }
            }
            //x轴行程/mm 起,取值时，乘1000
            PMIF.IDC_EDIT_XSTART.Text = (m_csemstagedataclr.GetXAxis().GetStart()/1000).ToString();
            //x轴行程/mm 始
            PMIF.IDC_EDIT_XEND.Text = (m_csemstagedataclr.GetXAxis().GetEnd()/1000).ToString();
            //y轴方向
            //PMIF.IDC_COMBO_YDIRECT.Text = ((OTS_Y_AXIS_DIRECTION)Enum.ToObject(typeof(OTS_Y_AXIS_DIRECTION), PMIF.m_csemstagedataclr.GetYAxisDir())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_YDIRECT.Items)
            {
                if (cbi.Value.ToString() != "")
                    if (Convert.ToInt32(cbi.Value) == Convert.ToInt32(m_csemstagedataclr.GetYAxisDir()))
                    {
                        PMIF.IDC_COMBO_YDIRECT.SelectedItem = cbi;
                    }
            }
            //y轴行程/mm 起
            PMIF.IDC_EDIT_YSTART.Text = (m_csemstagedataclr.GetYAxis().GetStart() / 1000).ToString();
            //y轴行程/mm 始
            PMIF.IDC_EDIT_YEND.Text = (m_csemstagedataclr.GetYAxis().GetEnd() / 1000).ToString();
            //最小放大倍数
            PMIF.IDC_EDIT_MINMAG.Text = m_csemstagedataclr.GetMinMag().ToString();
        }

        /// <summary>
        /// 加载图像扫描参数
        /// </summary>
        public void LoadImageScanPrm()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.LoadImageScanPrm)  加载图像扫描参数");
            loger.Trace("(OTSProgMgrInfoFun.LoadImageScanPrm)  加载图像扫描参数");
            //测量终止方式
            //PMIF.IDC_COMBO_STOPMODE.Text = ((OTS_MEASURE_STOP_MODE)Enum.ToObject(typeof(OTS_MEASURE_STOP_MODE), PMIF.m_cotsimgscanprmclr.GetStopMode())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_STOPMODE.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_MEASURE_STOP_MODE)cbi.Value == m_cotsimgscanprmclr.GetStopMode())
                    {
                        PMIF.IDC_COMBO_STOPMODE.SelectedItem = cbi;
                    }
            }
            //终止时间
            PMIF.IDC_EDIT_STOP_TIME.Text = m_cotsimgscanprmclr.GetStopParamMeasTime().ToString();
            //终止帧图数
            PMIF.IDC_EDIT_STOP_FIELD_NUM.Text = m_cotsimgscanprmclr.GetStopParamFields().ToString();
            //终止夹杂物数
            PMIF.IDC_EDIT_STOP_INCA_NUM.Text = m_cotsimgscanprmclr.GetStopParamParticles().ToString();
            //取图方式
            //PMIF.IDC_COMBO_FETCHIMGMODE.Text = ((OTS_GET_IMAGE_MODE)Enum.ToObject(typeof(OTS_GET_IMAGE_MODE), PMIF.m_cotsimgscanprmclr.GetStartImageMode())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_FETCHIMGMODE.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_GET_IMAGE_MODE)cbi.Value == m_cotsimgscanprmclr.GetStartImageMode())
                    {
                        PMIF.IDC_COMBO_FETCHIMGMODE.SelectedItem = cbi;
                    }
            }
            //扫描图精度
            //PMIF.IDC_COMBO_IMGSCANSPEED.Text = ((OTS_THREE_TIES_OPTIONS)Enum.ToObject(typeof(OTS_THREE_TIES_OPTIONS), PMIF.m_cotsimgscanprmclr.GetScanImageSpeed())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_IMGSCANSPEED.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_THREE_TIES_OPTIONS)cbi.Value == m_cotsimgscanprmclr.GetScanImageSpeed())
                    {
                        PMIF.IDC_COMBO_IMGSCANSPEED.SelectedItem = cbi;
                    }
            }
            //扫描图尺寸
            //PMIF.IDC_COMBO_IMGSIZE.Text = ((OTS_FIVE_TIES_OPTIONS)Enum.ToObject(typeof(OTS_FIVE_TIES_OPTIONS), PMIF.m_cotsimgscanprmclr.GetImagePixelSize())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_IMGSIZE.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_FIVE_TIES_OPTIONS)cbi.Value == m_cotsimgscanprmclr.GetImagePixelSize())
                    {
                        PMIF.IDC_COMBO_IMGSIZE.SelectedItem = cbi;
                    }
            }

            //PMIF.IDC_STOP_MODE_SWITCH.Checked = m_cotsimgscanprmclr.GetShowStopMode();
            //PMIF.IDC_STOP_TIME_SWITCH.Checked = m_cotsimgscanprmclr.GetShowMeasTime();
            //PMIF.IDC_STOP_FIELD_SWITCH.Checked = m_cotsimgscanprmclr.GetShowParamFields();
            //PMIF.IDC_STOP_PARTICAL_SWITCH.Checked = m_cotsimgscanprmclr.GetShowParticles();
            //PMIF.IDC_FETCH_IMAGE_SWITCH.Checked = m_cotsimgscanprmclr.GetShowStartImageMode();
            //PMIF.IDC_SCAN_SPEED_SWITCH.Checked = m_cotsimgscanprmclr.GetShowImageSpeed();
            //PMIF.IDC_IMAGE_SIZE_SWITCH.Checked = m_cotsimgscanprmclr.GetShowPixelSize();

            //帧结束方式
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_FrameEndMode.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_MEASURE_FIELD_STOP_MODE)cbi.Value == m_cotsimgscanprmclr.GetFieldStopMode())
                    {
                        PMIF.IDC_COMBO_FrameEndMode.SelectedItem = cbi;
                    }
            }

            //帧结束方式对应参数
            if (PMIF.IDC_COMBO_FrameEndMode.SelectedItem.ToString() == "颗粒百分比")
            {
                PMIF.IDC_EDIT_FrameEndModeParam.Text = m_cotsimgscanprmclr.GetFieldSmallParticlesPercentage().ToString();
            }
            else if (PMIF.IDC_COMBO_FrameEndMode.SelectedItem.ToString() == "颗粒数量")
            {
                PMIF.IDC_EDIT_FrameEndModeParam.Text = m_cotsimgscanprmclr.GetFieldSmallParticleNum().ToString();
            }

        }

        /// <summary>
        /// 加载一般常规参数
        /// </summary>
        public void LoadCGenParam()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.LoadCGenParam)  加载一般常规参数");

            //样品名
            PMIF.IDC_EDIT_SAMPLENAME.Text = m_cgenparamclr.GetSampleName().ToString();
            //执行开关
            PMIF.IDC_MEAS_SWITCH.Checked = m_cgenparamclr.GetMeasurementSwitch();
            //测量参数文件夹
            PMIF.IDC_EDIT_MEASUREPARAMPATH.Text = m_cgenparamclr.GetMsrParamFileFolderName().ToString();

            //样品测量参数文件,不保存，所以也不需要指定读取
            //PMIF.IDC_EDIT_MESA_PARAM_FILE.Text = m_cgenparamclr.getpar().ToString();

            
            //颗粒分析标准库文件夹
            //PMIF.IDC_EDIT_ANALYSESTDLIBPATH.Text = m_cgenparamclr.GetPartSTDLibFolderName().ToString();
            //颗粒分析标准库
            //PMIF.IDC_EDIT_STDLIBNAME.Text = m_cgenparamclr.GetPartSTDLib().GetName().ToString();

            //通过这个路径先load一下，再取库名？
            //PMIF.IDC_EDIT_STDLIBNAME.Text = m_cgenparamclr.GetPartSTDLibName();

            //先获取std文件类名，颗粒分析库名
            //m_cgenparamclr.GetPartSTDLib().GetName();
            //CPartSTDDataClr csdc = new CPartSTDDataClr();
            //csdc.SetName(PMIF.IDC_EDIT_STDLIBNAME.Text);
            //m_cgenparamclr.SetPartSTDLib(csdc);

            //选择颗粒分析标准库
            //foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_STDLIBSELECT.Items)
            //{
            //    if (cbi.Value.ToString() != "")
            //        if (Convert.ToInt32(cbi.Value) == m_cgenparamclr.GetPartStdLibTypeIndex())
            //        {
            //            PMIF.IDC_COMBO_STDLIBSELECT.SelectedItem = cbi;
            //        }
            //}

            ////选择颗粒分析标准库
            //foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_TECHNOLOGY.Items)
            //{
            //    if (cbi.Value.ToString() != "")
            //        if (Convert.ToInt32(cbi.Value) == m_cgenparamclr.GetPartStdLibTypeIndex())
            //        {
            //            //PMIF.IDC_COMBO_TECHNOLOGY.SelectedItem = cbi;
            //        }
            //}

            //精炼工艺选项
            //foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_TECHNOLOGY.Items)
            //{
            //    if (cbi.Value.ToString() != "")
            //        if (Convert.ToInt32(cbi.Value) == m_cgenparamclr.GetSteelTechnology())
            //        {
            //            PMIF.IDC_COMBO_TECHNOLOGY.SelectedItem = cbi;
            //        }
            //}

            //测量区域形状
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.cBMeasShape.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((DOMAIN_SHAPE)cbi.Value == m_cgenparamclr.GetShape())
                    {
                        PMIF.cBMeasShape.SelectedItem = cbi;
                    }
            }
            //测量区域面积
            PMIF.tBMeasArea.Text = m_cgenparamclr.GetArea().ToString();
            //实验室
            PMIF.tBLaboratoty.Text = m_cgenparamclr.GetLaboratoty().ToString();
            //分析参考号码
            PMIF.tBAnalysisReferenceNumber.Text = m_cgenparamclr.GetAnalysisReferenceNumber().ToString();
            //分析参考号码
            PMIF.tBCustomerName.Text = m_cgenparamclr.GetCustomerName().ToString();
            //样品描述
            PMIF.tBSampleDescription.Text = m_cgenparamclr.GetSampleDescription().ToString();
            //操作员姓名
            PMIF.tBOperatorName.Text = m_cgenparamclr.GetOperatorName().ToString();
            //注释
            PMIF.tBComment.Text = m_cgenparamclr.GetComment().ToString();
            //模式
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_Model.Items)
            {
                if (cbi.Value.ToString() != "")
                    if (Convert.ToInt32(cbi.Value) == m_cgenparamclr.GetModel())
                    {
                        PMIF.IDC_COMBO_Model.SelectedItem = cbi;
                    }
            }


        }

        /// <summary>
        /// 加载图像处理参数
        /// </summary>
        public void LoadImageProc()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.LoadImageProc)  加载图像处理参数");

            //颗粒面积范围 最小
            PMIF.IDC_EDIT_PARTAREAMIN.Text = m_cotsimgprocprmclr.GetIncAreaRange().GetStart().ToString();
            //颗粒面积范围 最大
            PMIF.IDC_EDIT_PARTAREAMAX.Text = m_cotsimgprocprmclr.GetIncAreaRange().GetEnd().ToString();
            //背景灰度范围 最小
            PMIF.IDC_EDIT_BACKMIN.Text = m_cotsimgprocprmclr.GetBGGray().GetStart().ToString();
            //背景灰度范围 最大
            PMIF.IDC_EDIT_BACKMAX.Text = m_cotsimgprocprmclr.GetBGGray().GetEnd().ToString();
            //颗粒灰度范围 最小
            PMIF.IDC_EDIT_PARTMIN.Text = m_cotsimgprocprmclr.GetParticleGray().GetStart().ToString();
            //颗粒灰度范围 最大
            PMIF.IDC_EDIT_PARTMAX.Text = m_cotsimgprocprmclr.GetParticleGray().GetEnd().ToString();

            //PMIF.IDC_PART_MIN_SWITCH.Checked = m_cotsimgprocprmclr.GetShowAreaLow();
            //PMIF.IDC_PART_MAX_SWITCH.Checked = m_cotsimgprocprmclr.GetShowAreaUp();
            //PMIF.IDC_BACK_MIN_SWITCH.Checked = m_cotsimgprocprmclr.GetShowBGLow();
            //PMIF.IDC_BACK_MAX_SWITCH.Checked = m_cotsimgprocprmclr.GetShowBGUp();
            //PMIF.IDC_PART_GRAY_MIN_SWITCH.Checked = m_cotsimgprocprmclr.GetShowPGLow();
            //PMIF.IDC_PART_GRAY_MAX_SWITCH.Checked = m_cotsimgprocprmclr.GetShowPGUp();

            //背景处理方式
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_AUTOBGREMOVE_TYPE.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_AUTOBGREMOVE_TYPE)cbi.Value == m_cotsimgprocprmclr.GetAutoBGRemoveType())
                    {
                        PMIF.IDC_COMBO_AUTOBGREMOVE_TYPE.SelectedItem = cbi;
                    }
            }

            //自动
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_AUTO.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_BGREMOVE_TYPE)cbi.Value == m_cotsimgprocprmclr.GetBGRemoveType())
                    {
                        PMIF.IDC_COMBO_AUTO.SelectedItem = cbi;
                    }
            }

        }

        /// <summary>
        /// 加载X-Ray参数
        /// </summary>
        public void LoadXRayParam()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.LoadXRayParam)  加载X-Ray参数");
            //搜索X-ray精度
            //PMIF.IDC_COMBO_SEARCHXRAYSPEED.Text = ((OTS_X_RAY_SCAN_MODE)Enum.ToObject(typeof(OTS_X_RAY_SCAN_MODE), PMIF.m_cotsxrayprmclr.GetSearchSpeed())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_SEARCHXRAYSPEED.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_THREE_TIES_OPTIONS)cbi.Value == m_cotsxrayprmclr.GetSearchSpeed())
                    {
                        PMIF.IDC_COMBO_SEARCHXRAYSPEED.SelectedItem = cbi;
                    }
            }

            //搜索X-ray精度对应的时间
            PMIF.IDC_TEXTBOX_SEARCHXRAYSPEED_TIME.Text = m_cotsxrayprmclr.GetMidSearchAQTime().ToString();

            //搜索X-ray最低计数
            //PMIF.IDC_EDIT_SEARCHXRAYCOUNTLIMIT.Text = m_cotsxrayprmclr.GetSearchCount().ToString();
            //X-ray扫描方式
            //PMIF.IDC_COMBO_XRAYSCANMODE.Text = ((OTS_THREE_TIES_OPTIONS)Enum.ToObject(typeof(OTS_THREE_TIES_OPTIONS), PMIF.m_cotsxrayprmclr.GetScanMode())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_XRAYSCANMODE.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_X_RAY_SCAN_MODE)cbi.Value == m_cotsxrayprmclr.GetScanMode())
                    {
                        PMIF.IDC_COMBO_XRAYSCANMODE.SelectedItem = cbi;
                    }
            }
            //分析X-ray精度
            //PMIF.IDC_COMBO_ANALYXRAYSPEED.Text = ((OTS_THREE_TIES_OPTIONS)Enum.ToObject(typeof(OTS_THREE_TIES_OPTIONS), PMIF.m_cotsxrayprmclr.GetAnalySpeed())).ToString();
            foreach (OTSPeriodicTable.ComboBoxItem cbi in PMIF.IDC_COMBO_ANALYXRAYSPEED.Items)
            {
                if (cbi.Value.ToString() != "")
                    if ((otsdataconst.OTS_THREE_TIES_OPTIONS)cbi.Value == m_cotsxrayprmclr.GetAnalySpeed())
                    {
                        PMIF.IDC_COMBO_ANALYXRAYSPEED.SelectedItem = cbi;
                    }
            }

            //分析X-ray精度对应的时间
            PMIF.IDC_TEXTBOX_ANALYXRAYSPEED_TIME.Text = m_cotsxrayprmclr.GetMidAnalyAQTime().ToString();

            //分析X-ray计数期望值
            PMIF.IDC_EDIT_ANALYXRAYAIMVALUE.Text = m_cotsxrayprmclr.GetAnalyExpCount().ToString();

            //PMIF.IDC_XRAY_MODE_SWITCH.Checked = m_cotsxrayprmclr.GetShowScanMode();
            //PMIF.IDC_XRAY_TIME_SWITCH.Checked = m_cotsxrayprmclr.GetShowSpeed();
            //PMIF.IDC_XRAY_COUNT_SWITCH.Checked = m_cotsxrayprmclr.GetShowExpCount();

        }

        /// <summary>
        /// 保存样品台信息
        /// </summary>
        public void SaveStageData()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.SaveStageData)  保存样品台信息");
        }

        /// <summary>
        /// 保存SEM样品台参数
        /// </summary>
        public void SaveSEMStageData()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.SaveSEMStageData)  保存SEM样品台参数");

            //100倍时屏幕尺寸/mm
            m_csemstagedataclr.SetScanFieldSize100(Convert.ToInt32(PMIF.IDC_EDIT_SCREENWIDTH.Text));

            //x轴方向
            //OTS_X_AXIS_DIRECTION enum_x = (OTS_X_AXIS_DIRECTION)Enum.Parse(typeof(OTS_X_AXIS_DIRECTION), PMIF.IDC_COMBO_XDIREC.SelectedItem.ToString(), false);
            OTSPeriodicTable. ComboBoxItem cbi_x = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_XDIREC.SelectedItem;
            m_csemstagedataclr.SetXAxisDir((otsdataconst.OTS_X_AXIS_DIRECTION)cbi_x.Value);

            //x轴行程/mm 起,始
            CIntRange crc_x = new CIntRange(Convert.ToInt32(PMIF.IDC_EDIT_XSTART.Text)*1000, Convert.ToInt32(PMIF.IDC_EDIT_XEND.Text)*1000);
            m_csemstagedataclr.SetXAxis(crc_x);

            //y轴方向
            //OTS_Y_AXIS_DIRECTION enum_y = (OTS_Y_AXIS_DIRECTION)Enum.Parse(typeof(OTS_Y_AXIS_DIRECTION), PMIF.IDC_COMBO_YDIRECT.SelectedItem.ToString(), false);
            OTSPeriodicTable.ComboBoxItem cbi_y = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_YDIRECT.SelectedItem;
            m_csemstagedataclr.SetYAxisDir((otsdataconst.OTS_Y_AXIS_DIRECTION)cbi_y.Value);

            //y轴行程/mm 起,始
            CIntRange crc_y = new CIntRange(Convert.ToInt32(PMIF.IDC_EDIT_YSTART.Text)*1000, Convert.ToInt32(PMIF.IDC_EDIT_YEND.Text)*1000);
            m_csemstagedataclr.SetYAxis(crc_y);

            //最小放大倍数
            m_csemstagedataclr.SetMinMag(Convert.ToDouble(PMIF.IDC_EDIT_MINMAG.Text));
        }

        /// <summary>
        /// 保存图像扫描参数
        /// </summary>
        public void SaveImageScanPrm()
        {
           //  保存图像扫描参数");

            //测量终止方式
            //OTS_MEASURE_STOP_MODE enum_stopmode = (OTS_MEASURE_STOP_MODE)Enum.Parse(typeof(OTS_MEASURE_STOP_MODE), PMIF.IDC_COMBO_STOPMODE.SelectedItem.ToString(), false);
            OTSPeriodicTable.ComboBoxItem enum_stopmode = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_STOPMODE.SelectedItem;
            m_cotsimgscanprmclr.SetStopMode((otsdataconst.OTS_MEASURE_STOP_MODE)enum_stopmode.Value);

            //终止时间
            m_cotsimgscanprmclr.SetStopParamMeasTime(Convert.ToInt32(PMIF.IDC_EDIT_STOP_TIME.Text));

            //终止帧图数
            m_cotsimgscanprmclr.SetStopParamFields(Convert.ToInt32(PMIF.IDC_EDIT_STOP_FIELD_NUM.Text));

            //终止夹杂物数
            m_cotsimgscanprmclr.SetStopParamParticles(Convert.ToInt32(PMIF.IDC_EDIT_STOP_INCA_NUM.Text));

            //取图方式
            //OTS_GET_IMAGE_MODE enum_fetchimgmode = (OTS_GET_IMAGE_MODE)Enum.Parse(typeof(OTS_GET_IMAGE_MODE), PMIF.IDC_COMBO_FETCHIMGMODE.SelectedItem.ToString(), false);
            OTSPeriodicTable.ComboBoxItem enum_fetchimgmode = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_FETCHIMGMODE.SelectedItem;
            m_cotsimgscanprmclr.SetStartImageMode((otsdataconst.OTS_GET_IMAGE_MODE)enum_fetchimgmode.Value);

            //扫描图精度
            //OTS_THREE_TIES_OPTIONS enum_imgscanspeed = (OTS_THREE_TIES_OPTIONS)Enum.Parse(typeof(OTS_THREE_TIES_OPTIONS), PMIF.IDC_COMBO_IMGSCANSPEED.SelectedItem.ToString(), false);
            OTSPeriodicTable.ComboBoxItem enum_imgscanspeed = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_IMGSCANSPEED.SelectedItem;
            m_cotsimgscanprmclr.SetScanImageSpeed((otsdataconst.OTS_THREE_TIES_OPTIONS)enum_imgscanspeed.Value);

            //扫描图尺寸
            //OTS_FIVE_TIES_OPTIONS enum_imgsize = (OTS_FIVE_TIES_OPTIONS)Enum.Parse(typeof(OTS_FIVE_TIES_OPTIONS), PMIF.IDC_COMBO_IMGSIZE.SelectedItem.ToString(), false);
            OTSPeriodicTable.ComboBoxItem enum_imgsize = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_IMGSIZE.SelectedItem;
            m_cotsimgscanprmclr.SetImagePixelSize((otsdataconst.OTS_FIVE_TIES_OPTIONS)enum_imgsize.Value);

            //m_cotsimgscanprmclr.SetShowStopMode(PMIF.IDC_STOP_MODE_SWITCH.Checked);
            //m_cotsimgscanprmclr.SetShowMeasTime(PMIF.IDC_STOP_TIME_SWITCH.Checked);
            //m_cotsimgscanprmclr.SetShowParamFields(PMIF.IDC_STOP_FIELD_SWITCH.Checked);
            //m_cotsimgscanprmclr.SetShowParticles(PMIF.IDC_STOP_PARTICAL_SWITCH.Checked);
            //m_cotsimgscanprmclr.SetShowStartImageMode(PMIF.IDC_FETCH_IMAGE_SWITCH.Checked);
            //m_cotsimgscanprmclr.SetShowImageSpeed(PMIF.IDC_SCAN_SPEED_SWITCH.Checked);
            //m_cotsimgscanprmclr.SetShowPixelSize(PMIF.IDC_IMAGE_SIZE_SWITCH.Checked);



            //帧结束方式
            OTSPeriodicTable.ComboBoxItem enum_FrameEndMode = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_FrameEndMode.SelectedItem;
            m_cotsimgscanprmclr.SetFieldStopMode((otsdataconst.OTS_MEASURE_FIELD_STOP_MODE)enum_FrameEndMode.Value);

            //帧结束方式对应参数
            if (PMIF.IDC_COMBO_FrameEndMode.SelectedItem.ToString()== "颗粒百分比")
            {
                m_cotsimgscanprmclr.SetFieldSmallParticlePercentage(Convert.ToInt32(PMIF.IDC_EDIT_FrameEndModeParam.Text));
            }
            else if (PMIF.IDC_COMBO_FrameEndMode.SelectedItem.ToString() == "颗粒数量")
            {
                m_cotsimgscanprmclr.SetFieldSmallParticleNum(Convert.ToInt32(PMIF.IDC_EDIT_FrameEndModeParam.Text));
            }

        }

        /// <summary>
        /// 保存一般常规参数
        /// </summary>
        public void SaveCGenParam()
        {
            //样品名
            m_cgenparamclr.SetSampleName(PMIF.IDC_EDIT_SAMPLENAME.Text);

            //执行开关
            m_cgenparamclr.SetMeasurementSwitch(PMIF.IDC_MEAS_SWITCH.Checked);

            //测量参数文件夹
            m_cgenparamclr.SetMsrParamFileFolderName(PMIF.IDC_EDIT_MEASUREPARAMPATH.Text);

            //样品测量参数文件,不需要保存了，改成选择，刷新整个程序管理窗体,再改，不需要了

            OTSPeriodicTable.ComboBoxItem cbi = new OTSPeriodicTable.ComboBoxItem();
            cbi = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_STDLIBSELECT.SelectedItem;
           // m_cgenparamclr.SetPartStdLibTypeIndex((int)cbi.Value);

            //颗粒分析标准库文件夹
            //m_cgenparamclr.SetPartSTDLibFolderName(PMIF.IDC_EDIT_ANALYSESTDLIBPATH.Text);

            //颗粒分析标准库
           // m_cpartstddataclr = m_cgenparamclr.GetPartSTDLib();//先取出，再传入
           // m_cpartstddataclr.SetName(PMIF.IDC_EDIT_STDLIBNAME.Text);
           // m_cgenparamclr.SetPartSTDLib(m_cpartstddataclr);

            //获取精炼工艺索引
            OTSPeriodicTable.ComboBoxItem cbiTECH = new OTSPeriodicTable.ComboBoxItem();
            cbiTECH = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_TECHNOLOGY.SelectedItem;
            //设置参数文件类中精炼工艺索引值
           // m_cgenparamclr.SetSteelTechnology((int)cbiTECH.Value);

            //测量区域形状
            OTSPeriodicTable.ComboBoxItem enum_Shape = (OTSPeriodicTable.ComboBoxItem)PMIF.cBMeasShape.SelectedItem;
            m_cgenparamclr.SetShape((DOMAIN_SHAPE)enum_Shape.Value);

            //测量区域大小
            m_cgenparamclr.SetArea(Convert.ToDouble(PMIF.tBMeasArea.Text));

            //模式选择
            OTSPeriodicTable.ComboBoxItem enum_Model = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_Model.SelectedItem;
            m_cgenparamclr.SetModel(Convert.ToInt32(enum_Model.Value));
            //实验室
            m_cgenparamclr.SetLaboratoty(PMIF.tBLaboratoty.Text);
            //分析参考号码
            m_cgenparamclr.SetAnalysisReferenceNumber(PMIF.tBAnalysisReferenceNumber.Text);
            //客户名称
            m_cgenparamclr.SetCustomerName(PMIF.tBCustomerName.Text);
            //操作员姓名
            m_cgenparamclr.SetOperatorName(PMIF.tBOperatorName.Text);
            //样品描述
            m_cgenparamclr.SetSampleDescription(PMIF.tBSampleDescription.Text);
            //注释
            m_cgenparamclr.SetComment(PMIF.tBComment.Text);
        }

        /// <summary>
        /// 保存图像处理参数
        /// </summary>
        public void SaveImageProc()
        {

            //颗粒面积范围 最小 最大
            CDoubleRange crc_partareamin = new CDoubleRange(Convert.ToDouble(PMIF.IDC_EDIT_PARTAREAMIN.Text), Convert.ToDouble(PMIF.IDC_EDIT_PARTAREAMAX.Text));
            m_cotsimgprocprmclr.SetIncAreaRange(crc_partareamin);

            //背景灰度范围 最小  最大
            CIntRange crc_backmin = new CIntRange(Convert.ToInt32(PMIF.IDC_EDIT_BACKMIN.Text), Convert.ToInt32(PMIF.IDC_EDIT_BACKMAX.Text));
            m_cotsimgprocprmclr.SetBGGray(crc_backmin);

            //颗粒灰度范围 最小  最大
            CIntRange crc_partmin = new CIntRange(Convert.ToInt32(PMIF.IDC_EDIT_PARTMIN.Text), Convert.ToInt32(PMIF.IDC_EDIT_PARTMAX.Text));
            m_cotsimgprocprmclr.SetParticleGray(crc_partmin);

            //m_cotsimgprocprmclr.SetShowAreaLow(PMIF.IDC_PART_MIN_SWITCH.Checked);
            //m_cotsimgprocprmclr.SetShowAreaUp(PMIF.IDC_PART_MAX_SWITCH.Checked);
            //m_cotsimgprocprmclr.SetShowBGLow(PMIF.IDC_BACK_MIN_SWITCH.Checked);
            //m_cotsimgprocprmclr.SetShowBGUp(PMIF.IDC_BACK_MAX_SWITCH.Checked);
            //m_cotsimgprocprmclr.SetShowPGLow(PMIF.IDC_PART_GRAY_MIN_SWITCH.Checked);
            //m_cotsimgprocprmclr.SetShowPGUp(PMIF.IDC_PART_GRAY_MAX_SWITCH.Checked);

            //搜索X-ray精度
            OTSPeriodicTable.ComboBoxItem enum_AUTOBGREMOVETYPE = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_AUTOBGREMOVE_TYPE.SelectedItem;
            m_cotsimgprocprmclr.SetBGRemoveType((otsdataconst.OTS_BGREMOVE_TYPE)enum_AUTOBGREMOVETYPE.Value);

            //搜索X-ray精度
            OTSPeriodicTable.ComboBoxItem enum_IMAGEMODE = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_AUTO.SelectedItem;
            m_cotsimgprocprmclr.SetAutoBGRemoveType((otsdataconst.OTS_AUTOBGREMOVE_TYPE)enum_IMAGEMODE.Value);
        }

        /// <summary>
        /// 保存X-Ray参数
        /// </summary>
        public void SaveXRayParam()
        {

            //搜索X-ray精度
            OTSPeriodicTable.ComboBoxItem enum_searchxrayspeed = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_SEARCHXRAYSPEED.SelectedItem;
            m_cotsxrayprmclr.SetSearchSpeed((otsdataconst.OTS_THREE_TIES_OPTIONS)enum_searchxrayspeed.Value);

            //搜索X - ray精度对应的时间
            m_cotsxrayprmclr.SetMidSearchAQTime(Convert.ToInt32(PMIF.IDC_TEXTBOX_SEARCHXRAYSPEED_TIME.Text.Trim()));

            //搜索X-ray最低计数
            //m_cotsxrayprmclr.SetSearchCount(Convert.ToInt32(PMIF.IDC_EDIT_SEARCHXRAYCOUNTLIMIT.Text));

            //X-ray扫描方式
            OTSPeriodicTable.ComboBoxItem enum_xrayscanmode = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_XRAYSCANMODE.SelectedItem;
            m_cotsxrayprmclr.SetScanMode((otsdataconst.OTS_X_RAY_SCAN_MODE)enum_xrayscanmode.Value);

            //分析X-ray精度
            OTSPeriodicTable.ComboBoxItem enum_analyxrayspeed = (OTSPeriodicTable.ComboBoxItem)PMIF.IDC_COMBO_ANALYXRAYSPEED.SelectedItem;
            m_cotsxrayprmclr.SetAnalySpeed((otsdataconst.OTS_THREE_TIES_OPTIONS)enum_analyxrayspeed.Value);

            //分析X-ray精度对应的时间
            m_cotsxrayprmclr.SetMidAnalyAQTime(Convert.ToInt32(PMIF.IDC_TEXTBOX_ANALYXRAYSPEED_TIME.Text.Trim()));

            //分析X-ray计数期望值
            m_cotsxrayprmclr.SetAnalyExpCount(Convert.ToInt32(PMIF.IDC_EDIT_ANALYXRAYAIMVALUE.Text));

            //m_cotsxrayprmclr.SetShowScanMode(PMIF.IDC_XRAY_MODE_SWITCH.Checked);
            //m_cotsxrayprmclr.SetShowSpeed(PMIF.IDC_XRAY_TIME_SWITCH.Checked);
            //m_cotsxrayprmclr.SetShowExpCount(PMIF.IDC_XRAY_COUNT_SWITCH.Checked);
        }

        /// <summary>
        /// 将参数保存到文件
        /// </summary>
        /// <param name="a_nPackId"></param>
        /// <param name="a_pStageData"></param>
        /// <param name="a_pGenParam"></param>
        /// <param name="a_pImageScanParam"></param>
        /// <param name="a_pImageProcParam"></param>
        /// <param name="a_pXRayParam"></param>
        /// <returns></returns>
        public bool SaveInfoToProgMgrFile()
        {
            if (false == m_cotsprogmgrparamfileclr.SaveInfoToProgMgrFile((int)OTS_SOFT_PACKAGE_ID.OTSIncA))
            {
                loger.Error("(OTSProgMgrInfoFun.SaveInfoToProgMgrFile)  将参数保存到文件失败");
                return false;
            }
            return true;
        }

        /// <summary>
        /// 加载参数各个类
        /// </summary>
        public bool LoadParamFun()
        {

            m_cotsprogmgrparamfileclr .LoadInfoFromProgMgrFile((int)OTS_SOFT_PACKAGE_ID.OTSIncA);
            if (null == m_cotsprogmgrparamfileclr)
            {
                loger.Error("(OTSProgMgrInfoFun.LoadParamFun)  LoadInfoFromProgMgrFile失败");
                return false;
            }

            m_csemstagedataclr = m_cstagefileclr.GetStageData();
            if (null == m_csemstagedataclr)
            {
                loger.Error("(OTSProgMgrInfoFun.LoadParamFun)  GetStageData失败");
                return false;
            }

            m_cotsimgscanprmclr = m_cotsprogmgrparamfileclr.GetImageScanParam();
            if (null == m_cotsimgscanprmclr)
            {
                loger.Error("(OTSProgMgrInfoFun.LoadParamFun)  GetImageScanParam失败");
                return false;
            }

            m_cgenparamclr = m_cotsprogmgrparamfileclr.GetGenParam();
            if (null == m_cgenparamclr)
            {
                loger.Error("(OTSProgMgrInfoFun.LoadParamFun)  GetGenParam失败");
                return false;
            }

            m_cotsimgprocprmclr = m_cotsprogmgrparamfileclr.GetImageProcParam();
            if (null == m_cotsimgprocprmclr)
            {
                loger.Error("(OTSProgMgrInfoFun.LoadParamFun)  GetImageProcParam失败");
                return false;
            }

            m_cotsxrayprmclr = m_cotsprogmgrparamfileclr.GetXRayParam();
            if (null == m_cotsxrayprmclr)
            {
                loger.Error("(OTSProgMgrInfoFun.LoadParamFun)  GetXRayParam失败");
                return false;
            }

            return true;
        }
        #endregion

        #region 自定义方法封装
        /// <summary>
        /// x轴方向 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetXAxisDirectionIdString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetXAxisDirectionIdString((otsdataconst.OTS_X_AXIS_DIRECTION)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetXAxisDirectionIdString)  获取x轴方向下拉项对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// y轴方向 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetYAxisDirectionIdString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetYAxisDirectionIdString((otsdataconst.OTS_Y_AXIS_DIRECTION)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetYAxisDirectionIdString)  y轴方向取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 测量终止方式 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetStopModeIdString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetStopModeIdString((otsdataconst.OTS_MEASURE_STOP_MODE)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetStopModeIdString)  测量终止方式 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 测量区域形状 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetAreaShapeString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetAreaShapeString((DOMAIN_SHAPE)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetAreaShapeString)  测量区域形状取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 模式选择 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetModelString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetModelString((otsdataconst.StartModel)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetModelString)  模式选择取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 帧结束方式 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetFrameEndModeString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetFrameEndModeString((otsdataconst.FrameEndMode)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetFrameEndModeString)  模式选择取enum中对应的中文名 失败");
            }
            return ls_str;
        }
        /// <summary>
        /// 背景处理方式 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetAUTOBGREMOVETYPEString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetAUTOBGREMOVETYPEString((otsdataconst.OTS_AUTOBGREMOVETYPE)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetAUTOBGREMOVETYPEString)  背景处理方式取enum中对应的中文名 失败");
            }
            return ls_str;
        }
        /// <summary>
        /// 自动 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetIMAGEMODEString(int i_enum)
        {
            string ls_str = "";
            ls_str = COTSProgMgr.GetIMAGEMODEString((otsdataconst.OTS_IMAGE_MODE)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetIMAGEMODEString)  IMAGEMODE自动项择取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 取图方式 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetGetImageIdString(int i_enum)
        {
            string ls_str = "";
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.GetGetImageIdString)   取图方式 ,取enum中对应的中文名");
            ls_str = COTSProgMgr.GetGetImageIdString((otsdataconst.OTS_GET_IMAGE_MODE)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetGetImageIdString)  取图方式 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 扫描图精度 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetScanSpeedString(int i_enum)
        {
            string ls_str = "";
            // 扫描图精度 ,取enum中对应的中文名");
            ls_str = COTSProgMgr.GetScanSpeedString((otsdataconst.OTS_THREE_TIES_OPTIONS)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetScanSpeedString)  扫描图精度 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 扫描图尺寸 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetImageSizeIdString(int i_enum)
        {
            string ls_str = "";
            //扫描图尺寸 ,取enum中对应的中文名");
            ls_str = COTSProgMgr.GetImageSizeIdString((otsdataconst.OTS_FIVE_TIES_OPTIONS)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetImageSizeIdString)  扫描图尺寸 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 搜索X-Ray精度 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetXRaySearchSpeedIdString(int i_enum)
        {
            string ls_str = "";
            // 搜索X-Ray精度 ,取enum中对应的中文名");
            ls_str = COTSProgMgr.GetXRaySearchSpeedIdString((otsdataconst.OTS_THREE_TIES_OPTIONS)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetXRaySearchSpeedIdString) 搜索X-Ray精度 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// X-Ray扫描方式 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetXRayScanModeIdString(int i_enum)
        {
            string ls_str = "";
            //  X-Ray扫描方式 ,取enum中对应的中文名");
            ls_str = COTSProgMgr.GetXRayScanModeIdString((otsdataconst.OTS_X_RAY_SCAN_MODE)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetXRayScanModeIdString)  X-Ray扫描方式 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        ///分析X-Ray精度 ,取enum中对应的中文名
        /// </summary>
        /// <param name="i_enum"></param>
        /// <returns></returns>
        public string GetXRayAnalySpeedIdString(int i_enum)
        {
            string ls_str = "";
            // 分析X-Ray精度 ,取enum中对应的中文名
            ls_str = COTSProgMgr.GetXRayAnalySpeedIdString((otsdataconst.OTS_THREE_TIES_OPTIONS)i_enum);
            if (ls_str == null)
            {
                loger.Error("(OTSProgMgrInfoFun.GetXRayAnalySpeedIdString)  分析X-Ray精度 ,取enum中对应的中文名 失败");
            }
            return ls_str;
        }

        /// <summary>
        /// 弹出样品台管理窗体
        /// </summary>
        /// <param name="a_nPackId"></param>
        /// <param name="a_pStageFile"></param>
        /// <returns></returns>
        public void ShowStageDialogExport(bool isuse)
        {
            //弹出样品台选择窗体
            m_cstagefileclr.SetInUse(isuse);

            DlgStageMgr m_dlgStageMgr = new DlgStageMgr();

            m_cstagefileclr = m_dlgStageMgr.ShowStageMgrDialog((int)OTS_SOFT_PACKAGE_ID.OTSIncA, m_cstagefileclr);

            if (null == m_cstagefileclr)
            {
                loger.Error("(OTSProgMgrInfoFun.ShowStageDialogExport) 弹出样品台选择窗体出错!");
            }

            return;
        }

        /// <summary>
        /// 保存样品台信息
        /// </summary>
        /// <returns></returns>
        public bool CStageFileClrSave()
        {
            //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.CStageFileClrSave) 保存样品台信息");
            if (m_cstagefileclr == null)
            {
                //报错
                loger.Error("(OTSProgMgrInfoFun.CStageFileClrSave) 保存样品台信息出错!");
            }
            else
            {
                bool b_ret = m_cstagefileclr.Save((int)OTS_SOFT_PACKAGE_ID.OTSIncA);
                if (false == b_ret)
                {
                    loger.Error("(OTSProgMgrInfoFun.CStageFileClrSave) 保存样品台信息出错!");
                }
            }
            return false;
        }

        ///// <summary>
        ///// 写追踪日志
        ///// </summary>
        ///// <param name="strLog"></param>
        ///// <returns></returns>
        //public int TraceLog(string strLog)
        //{
        //   return loger.Trace(strLog);
        //}

        /// <summary>
        /// 写错误日志
        /// </summary>
        /// <param name="strLog"></param>
        /// <returns></returns>
        //public int TraceErrorLog(string strLog)
        //{
        //    return loger.Error(strLog);
        //}

        /// <summary>
        /// 获取颗粒分析标准库文件列表
        /// </summary>
        /// <param name="listSTDLibName"></param>
        /// <returns></returns>
        //public List<CSTDItemClr> GetStdItemsList()
        //{
        //    //m_LogFunExport.TraceLog("(OTSProgMgrInfoFun.GetStdFileList) 获取STD颗粒分析标准库文件列表");
        //    List<CSTDItemClr> ret_cstditemclr = new List<CSTDItemClr>();
        //    ret_cstditemclr = m_cotsprogmgrparamfileclr.GetGenParam().GetPartSTDLib().GetSTDItemsList();
        //    if (null == ret_cstditemclr)
        //    {
        //        loger.Error("(OTSProgMgrInfoFun.GetStdFileList) 获取STD颗粒分析标准库文件列表出错!");
        //    }
        //    return ret_cstditemclr;
        //}
        #endregion

    }
}