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

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

namespace OTSDataType
{
    public class COTSImageProcParam : ISlo
    {
        int DEFUALT_PARTICALE_AREA_MIN = 1;
        int DEFUALT_PARTICALE_AREA_MAX = 200;
        int DEFUALT_BG_GRAY_LEVEL_MIN = 150;
        int DEFUALT_BG_GRAY_LEVEL_MAX = 255;
        int DEFUALT_PARTICLE_GRAY_LEVEL_MIN = 5;
        int DEFUALT_PARTICLE_GRAY_LEVEL_MAX = 155;
        private CDoubleRange m_oIncArea = new CDoubleRange();
        private CIntRange m_oBGGray = new CIntRange();
        private CIntRange m_oParticleEigenGray = new CIntRange();
        private OTS_BGREMOVE_TYPE m_BGRemoveType;
        private OTS_AUTOBGREMOVE_TYPE m_autoBGRemoveType;
        int m_OverlapParam;

        private CSpecialGrayRangeParam m_specialGreyRangeParam;
        private string particleSelectCondition = "";
        private double matrixStep = 1;

        public double MatrixStep { get => matrixStep; set => matrixStep = value; }

        public string GetParticleSelectCondition()
        {
            return particleSelectCondition;
        }
        public Dictionary<string, CDoubleRange> GetParticleSelConditionDic()
        {
            Dictionary<string, CDoubleRange> dic = new Dictionary<string, CDoubleRange>();
            if (particleSelectCondition != "" && particleSelectCondition!=null)
            {
                var conditionstrs = particleSelectCondition.Split(',');
               
                foreach (var singlecondition in conditionstrs)
                {
                    string conditionName = singlecondition.Split(':')[0];
                    string condition = singlecondition.Split(':')[1];
                    CDoubleRange rng = new CDoubleRange();
                    rng.SetStart(Convert.ToDouble(condition.Split('-')[0]));
                    rng.SetEnd(Convert.ToDouble(condition.Split('-')[1]));
                    dic.Add(conditionName, rng);
                }
              

            }
            return dic;
        
        }

        public void SetParticleSelectCondition(string value)
        {
            particleSelectCondition = value;
        }

        public CSpecialGrayRangeParam GetSpecialGreyRangeParam()
        {
            if (m_specialGreyRangeParam == null)
            {
                m_specialGreyRangeParam = new CSpecialGrayRangeParam();
            }

            return m_specialGreyRangeParam;
        }

        public void SetSpecialGreyRangeParam(CSpecialGrayRangeParam value)
        {
            m_specialGreyRangeParam = value;
        }

        public COTSImageProcParam()
        {
            Init();
        }
        public COTSImageProcParam(COTSImageProcParam a_oSource)
        {
            Init();
            // copy data over
            Duplicate(a_oSource);
        }
        public void Init()
        {
            m_specialGreyRangeParam = new CSpecialGrayRangeParam();
            m_oIncArea = new CDoubleRange(DEFUALT_PARTICALE_AREA_MIN, DEFUALT_PARTICALE_AREA_MAX);
            m_oBGGray = new CIntRange(DEFUALT_BG_GRAY_LEVEL_MIN, DEFUALT_BG_GRAY_LEVEL_MAX);
            m_oParticleEigenGray = new CIntRange(DEFUALT_PARTICLE_GRAY_LEVEL_MIN, DEFUALT_PARTICLE_GRAY_LEVEL_MAX);
            m_BGRemoveType = OTS_BGREMOVE_TYPE.MANUAL;// OTS_BGREMOVE_TYPE.AUTO;
            m_autoBGRemoveType = OTS_AUTOBGREMOVE_TYPE.MIDDLE;           
            m_OverlapParam = 20;
        }
        public CDoubleRange GetIncAreaRange() { return m_oIncArea; }
        public void SetIncAreaRange(CDoubleRange a_oVal) { m_oIncArea = a_oVal; }

        public CIntRange GetBGGray() { return m_oBGGray; }
        public void SetBGGray(CIntRange a_oVal) { m_oBGGray = a_oVal; }

        public CIntRange GetParticleGray() { return m_oParticleEigenGray; }
        public void SetParticleGray(CIntRange a_oVal) { m_oParticleEigenGray = a_oVal; }

        public OTS_BGREMOVE_TYPE GetBGRemoveType() { return m_BGRemoveType; }

        public void SetBGRemoveType(OTS_BGREMOVE_TYPE a_oVal) { m_BGRemoveType = a_oVal; }

        public OTS_AUTOBGREMOVE_TYPE GetAutoBGRemoveType() { return m_autoBGRemoveType; }

        public void SetAutoBGRemoveType(OTS_AUTOBGREMOVE_TYPE a_oVal) { m_autoBGRemoveType = a_oVal; }

       

        public int GetOverlapParam() { return m_OverlapParam; }

       public void SetOverlapParam(int overlap) { m_OverlapParam = overlap; }


        public void Duplicate(COTSImageProcParam a_oSource)
        {

            // copy data over
           
            m_oIncArea.SetStart(a_oSource.m_oIncArea.GetStart());
            m_oIncArea.SetEnd(a_oSource.m_oIncArea.GetEnd());
            m_oBGGray.SetStart(a_oSource.m_oBGGray.GetStart());
            m_oBGGray.SetEnd(a_oSource.m_oBGGray.GetEnd());
            m_oParticleEigenGray.SetStart(a_oSource.m_oParticleEigenGray.GetStart());
            m_oParticleEigenGray.SetEnd(a_oSource.m_oParticleEigenGray.GetEnd());
            m_BGRemoveType = a_oSource.m_BGRemoveType;
            m_autoBGRemoveType = a_oSource.m_autoBGRemoveType;
            SetParticleSelectCondition(a_oSource.GetParticleSelectCondition());
            m_OverlapParam = a_oSource.m_OverlapParam;
            matrixStep = a_oSource.matrixStep;

        }
        public bool Equals(COTSImageProcParam a_oSource)
        {

            // return test result
            return m_oIncArea == a_oSource.m_oIncArea &&
                m_oBGGray == a_oSource.m_oBGGray &&
                m_oParticleEigenGray == a_oSource.m_oParticleEigenGray &&
               
                m_OverlapParam == a_oSource.m_OverlapParam;

        }


        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
           

            Slo slo = new Slo();
            slo.Register("IncArea", m_oIncArea);
          
            slo.Register("BGGray", m_oBGGray);
           
            slo.Register("ParticleGray", m_oParticleEigenGray);

            xInt xnOverlapParam = new xInt();
            slo.Register("OverlapParam", xnOverlapParam);

            xString xnBGRemoveType = new xString();
            xString xnautoBGRemoveType = new xString();

            slo.Register("BGRemoveType", xnBGRemoveType);
            slo.Register("AutoBGRemoveType", xnautoBGRemoveType);

            xString xpartselcondition = new xString();
            slo.Register("ParticleSelectionCondition", xpartselcondition);
            xDouble xmatrixstep = new xDouble();
            slo.Register("MatrixStep", xmatrixstep);

            if (isStoring)
            {

                xnBGRemoveType.AssignValue((int)m_BGRemoveType+":"+m_BGRemoveType.ToString());
                xnautoBGRemoveType.AssignValue((int)m_autoBGRemoveType+":"+m_autoBGRemoveType.ToString());
               
                xnOverlapParam.AssignValue(m_OverlapParam);
                xpartselcondition.AssignValue(GetParticleSelectCondition());
                xmatrixstep.AssignValue(matrixStep);
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);
                //自动去背景设置
                m_BGRemoveType = (OTS_BGREMOVE_TYPE)Convert.ToInt32( xnBGRemoveType.value().Split(':')[0]);
                m_autoBGRemoveType = (OTS_AUTOBGREMOVE_TYPE)Convert.ToInt32( xnautoBGRemoveType.value().Split(':')[0]);
              
                m_OverlapParam = Convert.ToInt32(xnOverlapParam.value());
                MatrixStep = Convert.ToDouble(xmatrixstep.value());
              
                SetParticleSelectCondition(xpartselcondition.value());
            }
        }
    }
}