三角计算

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;

namespace workstation.view.image
{
    public class DrawAngle:DrawObject
    {
        private Point startPoint;
        private Point endPoint;
        private Point endPoint1;
        private const string entryStart = "Start";
        private const string entryEnd = "End";

        /// <summary>
        ///  Graphic objects for hit test
        /// </summary>
        private GraphicsPath areaPath = null;
        private Pen areaPen = null;
        private Region areaRegion = null;
        public DrawAngle()
        {
 
        }
        public DrawAngle(int x1, int y1, int x2, int y2)
            : base()
        {
            startPoint.X = x1;
            startPoint.Y = y1;
            endPoint.X = x2;
            endPoint.Y = y2;
            endPoint1.X = x2;
            endPoint1.Y = y2 + 20;
            Initialize();
        }
        /// <summary>
        /// Clone this instance
        /// </summary>
        public override DrawObject Clone()
        {
            DrawAngle drawAngle = new DrawAngle();
            drawAngle.startPoint = this.startPoint;
            drawAngle.endPoint = this.endPoint;
            drawAngle.endPoint1 = this.endPoint1;

            FillDrawObjectFields(drawAngle);
            return drawAngle;
        }

        public override void Draw(Graphics g)
        {
            g.SmoothingMode = SmoothingMode.AntiAlias;
            //endPoint1.X = endPoint.X + 3;
            //endPoint1.Y = endPoint.Y - 15;
            Pen pen = new Pen(Color, PenWidth);

            g.DrawLine(pen, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
            g.DrawLine(pen, startPoint.X, startPoint.Y, endPoint1.X, endPoint1.Y);
            g.DrawString(Angle(startPoint, endPoint, endPoint1) + "°", new Font("宋体", 9, FontStyle.Regular), new SolidBrush(myControls.MyColor.colol3), new PointF(startPoint.X, startPoint.Y - 10));

            //g.DrawString(LineLen(startPoint,endPoint)+"", new Font("宋体", 9, FontStyle.Regular), new SolidBrush(myControls.MyColor.colol3), endPoint);
            //g.DrawString(LineLen(startPoint, endPoint1)+"", new Font("宋体", 9, FontStyle.Regular), new SolidBrush(myControls.MyColor.colol3), endPoint1);
            //g.DrawString(LineLen(endPoint, endPoint1) + "", new Font("宋体", 9, FontStyle.Regular), new SolidBrush(myControls.MyColor.colol3), new PointF(Math.Abs(endPoint.X-endPoint1.X),endPoint1.Y));
            pen.Dispose();
        }
        public string Angle(Point p1,Point p2,Point p3)
        {
            double a = LineLen(p1, p2);
            double b = LineLen(p1, p3);
            double c = LineLen(p3, p2);
            if (2*a*b==0)
            {
                return 0+"";
            }
            return ((Math.Acos((double)(a * a + b * b - c * c) / (2 * a * b)))*180/3.14).ToString("f");

        }
        private double LineLen(Point sp1, Point sp2)
        {
            int a = Math.Abs(sp1.X - sp2.X);
            int b = Math.Abs(sp1.Y - sp2.Y);
            return Math.Sqrt((double)a * a + (double)b * b);
          
        }
        public override int HandleCount
        {
            get
            {
                return 3;
            }
        }

        /// <summary>
        /// Get handle point by 1-based number
        /// </summary>
        /// <param name="handleNumber"></param>
        /// <returns></returns>
        public override Point GetHandle(int handleNumber)
        {
            if (handleNumber == 1)
                return startPoint;
            else if (handleNumber == 2)
                return endPoint;
            else
                return endPoint1;
        }

        /// <summary>
        /// Hit test.
        /// Return value: -1 - no hit
        ///                0 - hit anywhere
        ///                > 1 - handle number
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public override int HitTest(Point point)
        {
            if (Selected)
            {
                for (int i = 1; i <= HandleCount; i++)
                {
                    if (GetHandleRectangle(i).Contains(point))
                        return i;
                }
            }

            if (PointInObject(point))
                return 0;

            return -1;
        }

        protected override bool PointInObject(Point point)
        {
            CreateObjects();

            return AreaRegion.IsVisible(point);
        }

        public override bool IntersectsWith(Rectangle rectangle)
        {
            CreateObjects();

            return AreaRegion.IsVisible(rectangle);
        }

        public override Cursor GetHandleCursor(int handleNumber)
        {
            switch (handleNumber)
            {
                case 1:
                case 2:
                    return Cursors.SizeAll;
                default:
                    return Cursors.Default;
            }
        }

        public override void MoveHandleTo(Point point, int handleNumber)
        {
            if (handleNumber == 1)
                startPoint = point;
            else if (handleNumber == 2)
                endPoint = point;
            else
                endPoint1 = point;

            Invalidate();
        }

        public override void Move(int deltaX, int deltaY)
        {
            startPoint.X += deltaX;
            startPoint.Y += deltaY;

            endPoint.X += deltaX;
            endPoint.Y += deltaY;

            endPoint1.X += deltaX;
            endPoint1.Y += deltaY;

            Invalidate();
        }

        /// <summary>
        /// Invalidate object.
        /// When object is invalidated, path used for hit test
        /// is released and should be created again.
        /// </summary>
        protected void Invalidate()
        {
            if (AreaPath != null)
            {
                AreaPath.Dispose();
                AreaPath = null;
            }

            if (AreaPen != null)
            {
                AreaPen.Dispose();
                AreaPen = null;
            }

            if (AreaRegion != null)
            {
                AreaRegion.Dispose();
                AreaRegion = null;
            }
        }

        /// <summary>
        /// Create graphic objects used from hit test.
        /// </summary>
        protected virtual void CreateObjects()
        {
            if (AreaPath != null)
                return;

            // Create path which contains wide line
            // for easy mouse selection
            AreaPath = new GraphicsPath();
            AreaPen = new Pen(Color.Black, 7);

            AreaPath.AddPolygon(new Point[] { new Point(startPoint.X, startPoint.Y), new Point(endPoint.X, endPoint.Y), new Point(endPoint1.X, endPoint1.Y) });
            AreaPath.Widen(AreaPen);

            // Create region from the path
            AreaRegion = new Region(AreaPath);
        }

        protected GraphicsPath AreaPath
        {
            get
            {
                return areaPath;
            }
            set
            {
                areaPath = value;
            }
        }

        protected Pen AreaPen
        {
            get
            {
                return areaPen;
            }
            set
            {
                areaPen = value;
            }
        }

        protected Region AreaRegion
        {
            get
            {
                return areaRegion;
            }
            set
            {
                areaRegion = value;
            }
        }
    }
}