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

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

        //stage data x direction
     //   const OTS_X_AXIS_DIRECTION STAGE_DATA_X_AXIS_DIRECTION = OTS_X_AXIS_DIRECTION.LEFT_TOWARD;

        const String STR_MEASURE_PREFERENCE_FILE_NAME = "OTSProgMgrParam.pmf";

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

        // measure switch
        const bool MEASURE_SWITCH = true;

        const int PROG_MGR_FILE_MARK = 'P' + 'R' + 'O' + 'J' + 'E' + 'K' + 'T' + 'M' + 'A' + 'N' + 'A' + 'G' + 'E' + 'R';

        // program manger file version
        const String PROG_MGR_FILE_VERSION = "1.1.1";

        // XRay scan mode												
        const OTS_X_RAY_SCAN_MODE SCAN_MODE = OTS_X_RAY_SCAN_MODE.PointMode;

        MemberBase m_Param;

        const String STR_APPNAME_OTSINCA = "OTSIncA";

        const String STR_COFIGPATH = "Config";

        const String STR_PROG_DATA = "ProData";

        const String STR_SYSTEM_DATA = "SysData";

        public COTSDefaultParam()
        {
            Init();
        }
        // copy constructor
        public COTSDefaultParam(COTSDefaultParam a_poSource)
        {

            Duplicate(a_poSource);
        }

        public COTSImgScanPrm GetImageScanParam() { return m_pImageScanParam; }

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

        public CSEMStageData GetStageDataParam() { return m_pStageDataParam; }


     


        // get path name													// file pathname
        public string GetPathName()
        {
            return m_strPathName;
        }

        public COTSGeneralParam GetGenParam() { return m_GenParam; }
        // set path name
        public void SetPathName(string a_strPathName)
        {
            m_strPathName = a_strPathName;
        }

        // get SEM stage data
        //CSEMStageDataPtr GetStageData() { return m_pStageData; }
        // Set SEM stage data
        //void SetStageData(CSEMStageDataPtr a_pStageData);

        // Read project manager information from project manager file 

        public bool LoadInfoFromProgMgrFile(otsdataconst.OTS_SOFT_PACKAGE_ID a_nPackId)
        {

            // get software pack measure preference file pathname
            string strProgMgrParamFilePathName = GetOTSPackMeasurePrefFilePathName((otsdataconst.OTS_SOFT_PACKAGE_ID)a_nPackId);
            if (string.IsNullOrEmpty(strProgMgrParamFilePathName))
            {
                logger.Info("LoadInfoFromProgMgrFile: failed to find program manager param file pathname.");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadInfoFromProgMgrFile: failed to find program manager param file pathname."));
                return false;
            }

            // program manager param file exists?
            if (Exists(strProgMgrParamFilePathName))
            {
                // tried to load it
                if (!Load(strProgMgrParamFilePathName))
                {
                    // failed to load the license info file
                    logger.Info("LoadLicenseInfoFile: failed to load license info file. pathname:"+strProgMgrParamFilePathName+".");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadLicenseInfoFile: failed to load license info file. pathname: %s"), strProgMgrParamFilePathName);
                    return false;
                }
            }
            else
            {
                // get app system file path
                string strCompanySysDataPath = GetOTSPackSysDataPathName((otsdataconst.OTS_SOFT_PACKAGE_ID)a_nPackId);
                if (string.IsNullOrEmpty(strCompanySysDataPath))
                {
                    // shouldn't happen, program manager param file pathname is empty, return nullptr
                    logger.Info("LoadInfoFromProgMgrFile: failed to company system data pathname.");  //LogErrorTrace(__FILE__, __LINE__, _T("LoadInfoFromProgMgrFile: failed to company system data pathname."));
                    return false;
                }

                // 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 = GetOTSPackProgDataPathName((otsdataconst.OTS_SOFT_PACKAGE_ID)a_nPackId);
                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(strProgMgrParamFilePathName))
                {
                    // 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 GetOTSPackProgDataPathName(OTS_SOFT_PACKAGE_ID a_nPackId)
        {
    

            // get common data pathname string
            String strCommonDataPathName = GetOSCommonDataPathName();
            if (strCommonDataPathName=="")
            {
                // can't common data path
              
                return "";
            }

            // software package program data pathname

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

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

        // creates a folder.
        public bool CreateFolder(string a_strFolder)
        {


            // create the folder
            //  bool bRet = CreateDirectory(strFolder, null) == true;
            Directory.CreateDirectory(a_strFolder);

            // return folder create result
            return true;
        }

        // check if the given string is valid file name or not
        // check if the given string is valid file name or not




        // get software pack preferece file path name


        // get software pack preference file path name
        public String GetOTSPackMeasurePrefFilePathName(OTS_SOFT_PACKAGE_ID a_nPackId)
        {
            // get software package system data pathname
            String strOTSPackSysDataPathName = GetOTSPackSysDataPathName(a_nPackId);

            // check if software package system data pathname is right
            if (strOTSPackSysDataPathName=="")
            {
                // failed to get software package system data pathname
                
                return "";
            }

            // software package project manager file pathname
            // i.e. "c:\ProgramData\OPTON\OTSIncA\SysData\OTSProgMgrParam.pmf"
            String strOTSPackProgMgrPathName = strOTSPackSysDataPathName + STR_MEASURE_PREFERENCE_FILE_NAME;

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

        // get software pack system data path
        public  String GetOTSPackSysDataPathName(OTS_SOFT_PACKAGE_ID a_nPackId)//deprecated,since we have build one new solution for the particle system.
        {
            // get app package name
            String strAppPackageName="";
            switch (a_nPackId)
            {
                case OTS_SOFT_PACKAGE_ID.OTSIncA:
                    strAppPackageName = STR_APPNAME_OTSINCA;
                    break;

                case OTS_SOFT_PACKAGE_ID.OTSPartA:
                    strAppPackageName = STR_APPNAME_OTSINCA;
                    break;

                default:
                   
                    return "";
            }

            // get common data pathname string
            String strCommonDataPathName = GetOSCommonDataPathName();
            if (strCommonDataPathName=="")
            {
                // can't common data path
               
                return "";
            }

            // software package system data pathname
            // e.g. "c:\ProgramData\OPTON\OTSIncA\SysData\"
            //CString strOTSSysDataPathName = strCommonDataPathName + STR_COFIGPATH + _T("\\") + strAppPackageName + _T("\\") + STR_SYSTEM_DATA + _T("\\");
            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()
        {

            String strPathName = ".\\";


            return strPathName;
        }

        // Save project manager information to project manager file

        // safe parameters into program preference file
        public bool SaveInfoToProgMgrFile(otsdataconst.OTS_SOFT_PACKAGE_ID a_nPackId)
        {

            // get software package system data path
            string strSoftwareSysDataPath = GetOTSPackSysDataPathName((otsdataconst.OTS_SOFT_PACKAGE_ID)a_nPackId);
            if (string.IsNullOrEmpty(strSoftwareSysDataPath))
            {
                // shouldn't happen, software package system data path string is empty
                logger.Info("SaveInfoToProgMgrFile: failed to software package system data path string.");  //LogErrorTrace(__FILE__, __LINE__, _T("SaveInfoToProgMgrFile: failed to software package system data path string."));
                return false;
            }

            //// software package system data path exists?
            //if (!Exists(strSoftwareSysDataPath))
            //{
            //    // software package system data path doesn't exists, create it
            //    if (!CreateFolder(strSoftwareSysDataPath))
            //    {
            //        // failed to create software package system data path, return FALSE
            //        logger.Info("SaveInfoToProgMgrFile: failed to create software package system data path.");  //LogErrorTrace(__FILE__, __LINE__, _T("SaveInfoToProgMgrFile: failed to create software package system data path."));
            //        return false;
            //    }
            //}

            // get software pack measure preference file pathname
            string strProgMgrParamFilePathName = GetOTSPackMeasurePrefFilePathName((otsdataconst.OTS_SOFT_PACKAGE_ID)a_nPackId);
            if (string.IsNullOrEmpty(strProgMgrParamFilePathName))
            {
                // shouldn't happen, software pack measure preference file pathname is empty, return nullptr
                logger.Info("SaveInfoToProgMgrFile: failed to find program manager param file pathname.");  //LogErrorTrace(__FILE__, __LINE__, _T("SaveInfoToProgMgrFile: failed to find program manager param file pathname."));
                return false;
            }

            // save parameters into program preference file
            if (!Save(strProgMgrParamFilePathName))
            {
                // 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;
        }

        // creates a folder.

       
        // check if the file exists or not
        public bool Exists(string a_sPath)
        {
            //return ::PathFileExists(a_sPath) == TRUE;
            if (File.Exists(a_sPath))
            {
                //MessageBox.Show(filePath + "  not exists!");
                //FileStream fs = File.Create(a_sPath);//创建文件
                //fs.Close();
                return  true;
            }
            else
            {           
                //System.Windows.Forms.MessageBox.Show(a_sPath + "  exists!");
                //执行读写操作
                return false;
            }
        }

        // load program manager file

        // 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)
        {
            xInt xProgMgrFileMark = new xInt();
            xString xProgMgrFileVersion = new xString();

            Slo slo = new Slo();
            slo.Register("ProgMgrFileMark", xProgMgrFileMark);
            slo.Register("ProgMgrFileVersion", xProgMgrFileVersion);
            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)
            {
                xProgMgrFileMark.AssignValue(PROG_MGR_FILE_MARK);
                xProgMgrFileVersion.AssignValue(PROG_MGR_FILE_VERSION);
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);
            }
        }
        public COTSGeneralParam GetDefaultParam()
        {
            return m_GenParam;
        }
        public void SetDefaultParam(COTSGeneralParam val)
        {
            m_GenParam = val;
        }

        // cleanup
        //protected void Cleanup()
        //{
        //}

        // initialization
        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);
        }
    }
}