OTS/OTSIncAMeasureApp/0-OTSModel/Measure/GetParamData/OTSDefaultParam.cs

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

namespace OTSModelSharp
{
   public  class COTSDefaultParam : ISlo
    {
        protected static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        // soft pack id
        public otsdataconst.OTS_SysType_ID m_nPackId;
        public otsdataconst.RunMode m_runmode;

        // SEM stage data
        CSEMStageData m_pStageDataParam;

        // general parameter
        COTSGeneralParam m_GenParam;

        // image scan parameter
        COTSImgScanPrm m_pImageScanParam;

        // image process parameter
        COTSImageProcParam m_pImageProcParam;

        // X-Ray parameter
        COTSXRayParam m_pXRayParam;

        // file pathname
        protected string m_strPathName;

        const int SCREEN_WIDTH_MAG100 = 1142;

        const long STAGE_DATA_X_AXIS_START = -100000;

        const long STAGE_DATA_X_AXIS_END = 100000;

        //stage data y start
        const long STAGE_DATA_Y_AXIS_START = -100000;

        //stage data y end
        const long STAGE_DATA_Y_AXIS_END = 100000;
   

        const String STR_MEASURE_PREFERENCE_FILE_NAME = "OTSProgMgrParam.pmf";

        // sample name
        const String SAMPLE_NAME = "Sample";

        // measure switch
        const bool MEASURE_SWITCH = true;

   

   

     

   

        const String STR_COFIGPATH = "Config";

        const String STR_PROG_DATA = "ProData";

        const String STR_SYSTEM_DATA = "SysData";

        public COTSDefaultParam()
        {
            Init();
        }

        public COTSImgScanPrm GetImageScanParam() { return m_pImageScanParam; }

        public COTSImageProcParam GetImageProcParam() { return m_pImageProcParam; }
        public COTSXRayParam GetXRayParam() { return m_pXRayParam; }

        public CSEMStageData GetStageDataParam() { return m_pStageDataParam; }


     



        public COTSGeneralParam GetGenParam() { return m_GenParam; }


        public bool LoadInfoFromProgMgrFile()
        {

            // get software pack measure preference file pathname
            string strProgMgrParamFileName = GetOTSMeasurePrefFileName();
   
            // program manager param file exists?
            if (Exists(strProgMgrParamFileName))
            {
                // tried to load it
                if (!Load(strProgMgrParamFileName))
                {
                    // failed to load the license info file
                    logger.Info("LoadLicenseInfoFile: failed to load license info file. pathname:"+strProgMgrParamFileName+".");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadLicenseInfoFile: failed to load license info file. pathname: %s"), strProgMgrParamFilePathName);
                    return false;
                }
            }
            else
            {
                // get app system file path
                string strCompanySysDataPath = GetOTSSysDataPathName();
    

                // company system data path exists?
                if (!Exists(strCompanySysDataPath))
                {
                    // company system data path doesn't exists, create it
                    Directory.CreateDirectory(strCompanySysDataPath);
              
                }

                // SEM stage
                CSEMStageData pStageData = new CSEMStageData();
                pStageData.SetScanFieldSize100(SCREEN_WIDTH_MAG100);
                CIntRange pXAxis = new CIntRange(Convert.ToInt32(STAGE_DATA_X_AXIS_START), Convert.ToInt32(STAGE_DATA_X_AXIS_END));
                pStageData.SetXAxis(pXAxis);
                CIntRange pYAxis = new CIntRange(Convert.ToInt32(STAGE_DATA_Y_AXIS_START), Convert.ToInt32(STAGE_DATA_Y_AXIS_END));
                pStageData.SetYAxis(pYAxis);
                pStageData.SetMinMag(otsdataconst.MAGNIFICATION_MIN);

                // general parameter
                COTSGeneralParam pGenParam = new COTSGeneralParam();
                pGenParam.SetSampleName(SAMPLE_NAME);
                pGenParam.SetMeasurementSwitch(MEASURE_SWITCH);

                // get software pack program data path
                string strOTSProDataPathName = GetOTSProgDataPathName();
                if (string.IsNullOrEmpty(strOTSProDataPathName))
                {
                    // shouldn't happen, software pack program data path is empty
                    logger.Info("LoadInfoFromProgMgrFile: failed to get software pack program data path.");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadInfoFromProgMgrFile: failed to get software pack program data path."));
                    return false;
                }

                pGenParam.SetMsrParamFileFolderName(strOTSProDataPathName);
                pGenParam.SetPartSTDLibFolderName(strOTSProDataPathName);

                //image scan parameter
                COTSImgScanPrm  pImageScanParam = new COTSImgScanPrm ();
                pImageScanParam.SetStopMode(DataPublic.STOPT_MODE);
                pImageScanParam.SetStopParamMeasTime(DataPublic.MEASURE_TIME);
                pImageScanParam.SetStopParamFields(DataPublic.FIELDS_NUM);
                pImageScanParam.SetStopParamParticles(DataPublic.PARTICL_NUM);
                pImageScanParam.SetStartImageMode(DataPublic.FETCH_IMAGE_MODE);
                pImageScanParam.SetScanImageSpeed(DataPublic.SCAN_SPEED);
                pImageScanParam.SetImagePixelSize(DataPublic.IMAGE_WIDTH);
                

                //image process parameter
                COTSImageProcParam  pImageProcParam = new COTSImageProcParam ();

                // particle area																						
                CDoubleRange INCA_AREA = new CDoubleRange(5, 100);
                // background gray
                CIntRange BACK_GRAY = new CIntRange(100, 255);
                // particle gray
                CIntRange INCA_GRAY = new CIntRange(5, 100);

                pImageProcParam.SetIncAreaRange(INCA_AREA);
                pImageProcParam.SetBGGray(BACK_GRAY);
                pImageProcParam.SetParticleGray(INCA_GRAY);

                // X-Ray parameter
                COTSXRayParam pXRayParam = new COTSXRayParam();
                pXRayParam.SetScanMode(DataPublic.SCAN_MODE);
                pXRayParam.SetSearchSpeed(DataPublic.SEARCH_SPEED);
                pXRayParam.SetXRaySearchCount(DataPublic.SEARCH_COUNT);
                pXRayParam.SetAnalySpeed(DataPublic.ANALYSIS_SPEED);
                pXRayParam.SetAnalyExpCount(DataPublic.ANALYSIS_EXPECT_COUNT);
                CSampleParam msrParam = new CSampleParam();
                msrParam.SetImageProcessParam(pImageProcParam);
                msrParam.SetImageScanParam(pImageScanParam);
                msrParam.SetXRayParam(pXRayParam);
                //pGenParam.SetMsrParam(msrParam);


                
                // create the program (preference) file
                if (!Save(strProgMgrParamFileName))
                {
                    // failed to create
                    logger.Info("LoadInfoFromProgMgrFile: create program manager file failed.");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadInfoFromProgMgrFile: create program manager file failed."));
                    return false;
                }
            }
            // ok, return the program (preference) file
            return true;
        }

        // get software pack program data path
       public String GetOTSProgDataPathName()
        {
    

            // get common data pathname string
            String strCommonDataPathName = GetOSCommonDataPathName();


            String strOTSProDataPathName = strCommonDataPathName + STR_COFIGPATH + "\\" + STR_PROG_DATA + "\\";

            // return software package program data path
            return strOTSProDataPathName;
        }

        public string GetSysType()
        {
            return m_nPackId.ToString();
        }

        // get software pack preference file path name
        public String GetOTSMeasurePrefFileName()
        {
            // get software package system data pathname
            String strOTSPackSysDataPathName = GetOTSSysDataPathName();


            String strOTSPackProgMgrPathName = strOTSPackSysDataPathName + STR_MEASURE_PREFERENCE_FILE_NAME;

            // return software package license file pathname 
            return strOTSPackProgMgrPathName;
        }

        // get software pack system data path
        public  String GetOTSSysDataPathName()//deprecated,since we have build one new solution for the particle system.
        {

            // get common data pathname string
            String strCommonDataPathName = GetOSCommonDataPathName();
      

            // software package system data pathname
         
            String strOTSSysDataPathName = strCommonDataPathName + STR_COFIGPATH + "\\" + STR_SYSTEM_DATA + "\\";

            // return software package system data path
            return strOTSSysDataPathName;
        }


        // get system common data folder pathname
        // return "" if failed
       public String GetOSCommonDataPathName()
        {

            return ".\\";
        }


        // safe parameters into program preference file
        public bool SaveInfoToProgMgrFile()
        {

            // get software pack measure preference file pathname
            string strProgMgrParamFileFullName = GetOTSMeasurePrefFileName();
          // save parameters into program preference file
            if (!Save(strProgMgrParamFileFullName))
            {
                // failed to save program preference file, return FALSE
                logger.Info("SaveInfoToProgMgrFile: failed to save program preference file.");  //LogErrorTrace(__FILE__, __LINE__, _T("SaveInfoToProgMgrFile: failed to save program preference file."));
                return false;
            }
            // ok, return TRUE
            return true;
        }

        // check if the file exists or not
        public bool Exists(string a_sPath)
        {
            //return ::PathFileExists(a_sPath) == TRUE;
            if (File.Exists(a_sPath))
            {

                return  true;
            }
            else
            {       
               
                //执行读写操作
                return false;
            }
        }


        // NOTE: be sure a_strPathName is a valid file pathname
        public bool Load(string a_strPathName)
        {
            // file pathname
            m_strPathName = a_strPathName;

            m_pStageDataParam = new CSEMStageData();

            m_GenParam = new COTSGeneralParam();
            // image scan parameter
            m_pImageScanParam = new COTSImgScanPrm();

            // image process parameter
            m_pImageProcParam = new COTSImageProcParam();

            // X-Ray parameter
            m_pXRayParam = new COTSXRayParam();

            XmlDocument doc = new XmlDocument();
            //载入xml文件
            doc.Load(a_strPathName); 

            XmlNode root = doc.SelectSingleNode("XMLData");
            Serialize(false, doc, root);

            
            return true;
        }
        // save program manager file 
        public bool Save(string a_strPathName)
        {
            //ASSERT(m_pStageData);
            //Debug.Assert(m_pParam);
            XmlDocument doc = new XmlDocument();
            doc.Load(a_strPathName);
            doc.RemoveAll();
            //添加xml文件头申明
            XmlDeclaration xmldecl = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
            doc.AppendChild(xmldecl);
            XmlElement rootNode = doc.CreateElement("XMLData");
            doc.AppendChild(rootNode);

            Serialize(true, doc, rootNode);
            try
            {
                doc.Save(a_strPathName);
            }
            catch
            {
                return false;
            }
            // file pathname
            m_strPathName = a_strPathName;
            // ok, return TRUE
            return true;
        }
        // serialization
        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
           
            xString xSysType = new xString();

            xString xRunMode = new xString();
            Slo slo = new Slo();
          
            slo.Register("SysType", xSysType);
            slo.Register("RunMode", xRunMode);
            slo.Register("StageData", m_pStageDataParam);
            slo.Register("GenParam", m_GenParam);
            slo.Register("ImageScanParam", m_pImageScanParam);
            slo.Register("ImageProcParam", m_pImageProcParam);
            slo.Register("XrayParam", m_pXRayParam);
            if (isStoring)
            {
                xSysType.AssignValue(m_nPackId.ToString());
                xRunMode.AssignValue(m_runmode.ToString());
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);

                switch (xSysType.value())
                {
                    case "IncA":
                        this.m_nPackId = OTS_SysType_ID.IncA;
                        break;
                    case "CleanlinessA":
                        this.m_nPackId = OTS_SysType_ID.CleanlinessA;
                        break;
                    default:
                        break;                                
                }
                switch (xRunMode.value())
                {
                    case "Proffectional":
                        this.m_runmode = otsdataconst.RunMode.ProfessionalMode;
                        break;
                    case "Plain":
                        this.m_runmode = RunMode.PlainMode;
                        break;
                    default:
                        break;
                }


            }
        }


        protected void Init()
        {
            m_strPathName = "";
        }

        // duplication
        protected void Duplicate(COTSDefaultParam a_oSource)
        {
            // initialization
            Init();

            // copy data over
            m_strPathName = a_oSource.m_strPathName;
            m_GenParam = new COTSGeneralParam(a_oSource.m_GenParam);
        }
    }
}