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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Xml;

using OTSCLRINTERFACE;
namespace OTSDataType
{


    public class CDomain : ISlo
    {
        protected const int DOMAIN_ITEM_NUMBER = 5;
        protected otsdataconst.DOMAIN_SHAPE m_nShape;
        protected Rectangle m_rectangle;
        protected List<Point> m_PolygonPoint;
    

        public CDomain()
        {
            m_nShape = (otsdataconst.DOMAIN_SHAPE)(-1);
            m_rectangle = new Rectangle(0, 0, 0, 0);
            m_PolygonPoint = new List<Point>();       
        }
        public CDomain(otsdataconst.DOMAIN_SHAPE a_nShape, Rectangle a_rectRegion)
        {
            m_nShape = a_nShape;
            m_rectangle = a_rectRegion;
            m_PolygonPoint = new List<Point>();
         
        }
        public CDomainClr GetClrDomainObj()
        {
           var myDomainClr = new CDomainClr((int)m_nShape, m_rectangle);
            myDomainClr.SetPolygonPoint(m_PolygonPoint);
            return myDomainClr;

        }
        public bool equals(CDomain a_source)
        {
            return m_nShape == a_source.m_nShape && m_rectangle == a_source.m_rectangle;
        }
        public CDomain(CDomain d)
        {
            Duplicate(d);
        }
       protected void Duplicate(CDomain a_oSource)
        {
            m_nShape = a_oSource.m_nShape;
            m_rectangle = new Rectangle(a_oSource.m_rectangle.Location, a_oSource.m_rectangle.Size);
            m_PolygonPoint = new List<Point>();
            foreach (var p in a_oSource.GetPolygonPoint())
            {
                m_PolygonPoint.Add(p);
            }
           
        }
        public bool IsInvalid()
        {
            return (m_nShape < otsdataconst.DOMAIN_SHAPE.ROUND) || m_nShape > otsdataconst.DOMAIN_SHAPE.RECTANGLE || m_rectangle.IsEmpty;

        }

        public void SetRectDomain(Rectangle val) 
        {
            m_rectangle= val;
          
        }

        public Rectangle GetRectDomain() { return m_rectangle; }

        public bool IsEmpty() { return m_rectangle.IsEmpty; }

        public bool IsRound() { return m_nShape == otsdataconst.DOMAIN_SHAPE.ROUND; }

        public bool IsRect() { return m_nShape == otsdataconst.DOMAIN_SHAPE.RECTANGLE; }

        public Point GetDomainCenter() { return new Point(m_rectangle.X + m_rectangle.Width / 2, m_rectangle.Y + m_rectangle.Height / 2); }

        public void OffsetDomain(Point a_poiMove) { m_rectangle.X += a_poiMove.X; m_rectangle.Y += a_poiMove.Y;  }

        public long GetDiameter() { return m_rectangle.Width; }

        public Rectangle GetDomainRect() { return m_rectangle; }

        public void SetDomainRect(Rectangle a_rect) { m_rectangle = new Rectangle(a_rect.Location, a_rect.Size); }

        public otsdataconst.DOMAIN_SHAPE GetShape() { return m_nShape; }

        public void SetShape(otsdataconst.DOMAIN_SHAPE a_nShape) { m_nShape = a_nShape;  }

        public void SetPolygonPoint(List<Point> a_PolygonPoint) 
        { 
            m_PolygonPoint = a_PolygonPoint; 
            //myDomainClr = new CDomainClr((int)m_nShape, m_rectangle); 
        }
        public List<Point> GetPolygonPoint() { return m_PolygonPoint; }

        public bool IntersectDomain(CDomain a_oDomain)
        {
            CDomainClr dom = GetClrDomainObj();
            var dom1 = a_oDomain.GetClrDomainObj();
            bool ifWithIn = dom.IntersectDomain(dom1);
            dom.MyDispose();
            dom1.MyDispose();
            return ifWithIn;



        }
        public bool PtInDomain( Point a_poiCheck) 
	    {
            var dom = GetClrDomainObj();
            dom.PtInDomain(a_poiCheck);
            dom.MyDispose();
            return true;


        }
        public bool  DomainInDomain( CDomain a_oDomain)
	   {
            var dom = GetClrDomainObj();
            var dom1 = a_oDomain.GetClrDomainObj();
            bool ifWithIn = dom.DomainInDomain(dom1);
            dom.MyDispose();
            dom1.MyDispose();
            return ifWithIn;

        }
         protected void Init()
        {
            m_nShape = (otsdataconst.DOMAIN_SHAPE)(-1);
            m_rectangle = new Rectangle(0, 0, 0, 0);
            m_PolygonPoint = new List<Point>();

        }

        public override void Serialize(bool isStoring, XmlDocument classDoc, XmlNode rootNode)
        {
            Slo slo = new Slo();
            xString xnShape = new xString();
            xRect xRecDomain = new xRect();
            xString xPolygonPoint = new xString();
            slo.Register("shape", xnShape);
            slo.Register("rectDomian", xRecDomain);
            slo.Register("PolygonPoint", xPolygonPoint);

            if (isStoring)
            {
                xnShape.AssignValue((int)m_nShape+":"+ m_nShape.ToString());
                //we have to save the rectangle parameter according to the previouse rule.(left,top,width,height or centerX centerY,diamiter,0)
                System.Drawing.Rectangle rect = new System.Drawing.Rectangle();
                rect.X = m_rectangle.X;
                rect.Y = m_rectangle.Y;
                rect.Width = m_rectangle.Width;
                rect.Height = m_rectangle.Height;
                xRecDomain.AssignValue(rect, (int)m_nShape);
                if (m_PolygonPoint != null)
                {
                    string pointStr;
                    pointStr = string.Join("_", m_PolygonPoint);
                    xPolygonPoint.AssignValue(pointStr);
                }
                slo.Serialize(true, classDoc, rootNode);
            }
            else
            {
                slo.Serialize(false, classDoc, rootNode);

                m_nShape = (otsdataconst.DOMAIN_SHAPE)Convert.ToInt32( xnShape.value().Split(':')[0]);
                List<string> rectDomain = xRecDomain.toString().Split(',').ToList();
                m_rectangle = new Rectangle(Convert.ToInt32(rectDomain[0]), Convert.ToInt32(rectDomain[1]), 0, 0);

                //do the regulation
                int nCentreX = m_rectangle.Left;
                int nCentreY = m_rectangle.Top;
                int nWidth;
                int nHeight;
                int nDiameter;
                if (m_nShape == otsdataconst.DOMAIN_SHAPE.ROUND)
                {
                    nDiameter = Convert.ToInt32(rectDomain[2]);
                    // create domain		
                    m_rectangle = new Rectangle(0, 0, nDiameter, nDiameter);
                    OffsetDomain(new Point(nCentreX - (nDiameter / 2), nCentreY - (nDiameter / 2)));
                }
                else if (m_nShape == otsdataconst.DOMAIN_SHAPE.RECTANGLE)
                {
                    nWidth = Convert.ToInt32(rectDomain[2]);
                    nHeight = Convert.ToInt32(rectDomain[3]);
                    m_rectangle = new Rectangle(0, 0, nWidth, nHeight);
                    OffsetDomain(new Point(nCentreX - (nWidth / 2), nCentreY - (nHeight / 2)));
                }
                if (m_PolygonPoint == null)
                {
                    m_PolygonPoint = new List<Point>();
                }
                //myDomainClr = new CDomainClr((int)m_nShape, m_rectangle);
                if (xPolygonPoint != null)
                {
                    if(xPolygonPoint.value() != null)
                    {
                        List<string> pointList = xPolygonPoint.toString().Split('_').ToList();
                        if (pointList.Count > 2)
                        {
                            foreach (var item in pointList)
                            {
                                // 先去掉大括号
                                string str = item.Replace("{", "").Replace("}", "");
                                int x = Convert.ToInt32(str.Split(',')[0].Split('=')[1]);
                                int y = Convert.ToInt32(str.Split(',')[1].Split('=')[1]);
                                Point point = new Point(x, y);
                                m_PolygonPoint.Add(point);
                            }
                        }
                    }
                }
            }
          
        }
    }
}