Metis_xctg/Annotation/FieldView/ViewCircle.cs

using PaintDotNet.Annotation.Enum;
using PaintDotNet.Base.CommTool;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.Runtime.Serialization;
using System.Windows.Forms;

namespace PaintDotNet.Annotation.FieldView
{
    /// <summary>
    /// 圆形视场绘制
    /// </summary>
    public class ViewCircle : ViewBase
    {
        #region Calculate
        List<Func<PointF>> m_circleTemple;

        float _radius;
        float _centerx;
        float _centery;

        public override double Width
        {
            get { return _radius * 2; }
            set
            {
                _centerx = Points[1].X;
                _centery = Points[3].Y;
                _radius = (float)value / 2;
                Points = CalculateCirclePoints();
            }
        }

        public override double Height => Width;
        void InitCircleTemplate()
        {
            m_circleTemple = new List<Func<PointF>>();
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF(-(float)(_radius / Math.Sqrt(2)), -(float)(_radius / Math.Sqrt(2))); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF(0, -_radius); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF((float)(_radius / Math.Sqrt(2)), -(float)(_radius / Math.Sqrt(2))); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF(_radius, 0); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF((float)(_radius / Math.Sqrt(2)), (float)(_radius / Math.Sqrt(2))); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF(0, _radius); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF(-(float)(_radius / Math.Sqrt(2)), (float)(_radius / Math.Sqrt(2))); }));
            m_circleTemple.Add(
                new Func<PointF>(() =>
                { return new PointF(-_radius, 0); }));
        }

        private List<PointF> CalculateCirclePoints()
        {
            List<PointF> points = new List<PointF>();
            foreach (var func in m_circleTemple)
            {
                var p = func.Invoke();
                points.Add(new PointF(p.X + _centerx, p.Y + _centery));
            }
            return points;
        }

        public override double Getacreage()
        {
            var r = BasicCalculationHelper.GetDistance(Points[0], Points[4]) / 2;
            return Math.PI * r * r;
        }
        #endregion

        #region Constructor
        public ViewCircle()
        {
            objectType = DrawClass.View;
            drawToolType = DrawToolType.ViewCircle;
            Initialize();
            InitCircleTemplate();
        }

        public ViewCircle(List<PointF> points) : this()
        {
            Points = points;
        }

        public ViewCircle(int x, int y) : this()
        {
            for (int i = 0; i < 8; i++) AddPoint(x, y);
        }
        #endregion

        #region Clone
        public override DrawObject Clone()
        {
            return Clone(ISurfaceBox);
        }

        public override DrawObject Clone(ISurfaceBox surfaceBox)
        {
            ViewCircle drawRectangle = new ViewCircle(Points);
            drawRectangle.ISurfaceBox = surfaceBox;
            drawRectangle.ID = ID;
            drawRectangle.combineMode = this.combineMode;
            drawRectangle.Color = Color;
            FillDrawObjectFields(drawRectangle);
            return drawRectangle;
        }
        #endregion

        #region Handle
        public override int HandleCount
        {
            get
            {
                return 8;
            }
        }

        public override PointF GetHandle(int handleNumber)
        {
            return Points[handleNumber - 1];
        }

        public override Cursor GetHandleCursor(int handleNumber)
        {
            switch (handleNumber)
            {
                case 1:
                    return Cursors.SizeNWSE;
                case 2:
                    return Cursors.SizeNS;
                case 3:
                    return Cursors.SizeNESW;
                case 4:
                    return Cursors.SizeWE;
                case 5:
                    return Cursors.SizeNWSE;
                case 6:
                    return Cursors.SizeNS;
                case 7:
                    return Cursors.SizeNESW;
                case 8:
                    return Cursors.SizeWE;
                default:
                    return Cursors.Default;
            }
        }

        public override void MoveHandleTo(Point point, int handleNumber)
        {
            if (handleNumber % 2 != 0)
                MoveCorner(point);
            else
                MoveEdage(point, handleNumber);
            OnPropertyChanged();
        }

        private void MoveCorner(Point point)
        {
            _centerx = Points[1].X;
            _centery = Points[3].Y;
            _radius = (float)BasicCalculationHelper.GetDistance(Center, point);
            Points = CalculateCirclePoints();
        }

        private void MoveEdage(Point point, int i)
        {
            if (i % 4 == 0)
            {
                i--;
                _centery = Points[3].Y;
                _centerx = (point.X + Points[(i + 4) % 8].X) / 2;
                _radius = Math.Abs(point.X - Points[(i + 4) % 8].X) / 2;
            }
            else
            {
                i--;
                _centerx = Points[1].X;
                _centery = (point.Y + Points[(i + 4) % 8].Y) / 2;
                _radius = Math.Abs(point.Y - Points[(i + 4) % 8].Y) / 2;
            }
            Points = CalculateCirclePoints();
        }
        #endregion
    }
}