MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

namespace MarkupToPDF.Controls.Common

{

    public class MathSet

    {

        const double Rad2Deg = 180.0 / Math.PI;

        const double Deg2Rad = Math.PI / 180.0;

        const double UnitAngle = 15;

        public static List<double> angleSet = new List<double>();

        public static double getMultipleAngle(double increase, double YourAngle)

        {

            angleSet.Clear();

            for (double i = 0; i <= 360; i += increase)

            {

                angleSet.Add(i);

            }

            if (YourAngle < 0)

            {

                YourAngle += 360;

            }

            double TargetData = YourAngle;

            double NearAngle = 0;

            double k = 0;

            foreach (var item in angleSet)

            {

                double j = 0;

                j = TargetData - item;

                j = j < 0 ? -j : j;

                if (j < k)

                {

                    NearAngle = item;

                }

                k = j;

            }

            return NearAngle;

        }

        public static Point getNearPoint(List<Point> pointList, Point setPoint)

        {

            Point nearPoint = pointList.Select

            (n => new

            {

                n,

                distance = Math.Sqrt

                    (

                        Math.Pow(

                                    (n.X - setPoint.X), 2

                                )

                        + System.Math.Pow

                        (

                            (n.Y - setPoint.Y), 2

                        )

                    )

            }

            ).OrderBy(p => p.distance).First().n;

            return nearPoint;

        }

        public class ClipLine

        {

            public static int DONT_INTERSECT = -0x01;

            public static int COLLINEAR = 0x00;

            public static int INTERSECT = 0x01;

            public static double TOLER = 0.0;

            public Point _start;

            public Point _end;

            public ClipLine(Point start, Point end)

            {

                _start = start;

                _end = end;

            }

            public bool IsLeftSide(Point pt)

            {

                double dx1 = _end.X - _start.X;

                double dy1 = _end.Y - _start.Y;

                double dx2 = pt.X - _start.X;

                double dy2 = pt.Y - _start.Y;

                return ((dx1 * dy2 - dy1 * dx2) > 0.0);

            }

            public bool IsRightSide(Point pt)

            {

                double dx1 = _end.X - _start.X;

                double dy1 = _end.Y - _start.Y;

                double dx2 = pt.X - _start.X;

                double dy2 = pt.Y - _start.Y;

                return ((dx1 * dy2 - dy1 * dx2) < 0.0);

            }

            /// <summary>

            /// get intersection point betwwen this and line2d

            /// </summary>

            /// <author>humkyung</author>

            /// <date>2012.08.30</date>

            /// <param name="intsec"></param>

            /// <param name="line2d"></param>

            /// <returns></returns>

            public int IntersectWith(ref Point intsec, ClipLine line2d)

            {

                double Ax = 0.0, Bx = 0.0, Cx = 0.0, Ay = 0.0, By = 0.0, Cy = 0.0, d = 0.0, e = 0.0, f = 0.0;

                double x1lo = 0.0, x1hi = 0.0, y1lo = 0.0, y1hi = 0.0;

                Ax = _end.X - _start.X;

                Bx = line2d._start.X - line2d._end.X;

                // X bound box test

                if (Ax < 0.0)

                {

                    x1lo = _end.X;

                    x1hi = _start.X;

                }

                else

                {

                    x1hi = _end.X;

                    x1lo = _start.X;

                }

                if (Bx > 0.0)

                {

                    if ((x1hi < line2d._end.X) || (line2d._start.X < x1lo)) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((x1hi < line2d._start.X) || (line2d._end.X < x1lo)) return ClipLine.DONT_INTERSECT;

                }

                Ay = _end.Y - _start.Y;

                By = line2d._start.Y - line2d._end.Y;

                /* Y bound box test*/

                if (Ay < 0)

                {

                    y1lo = _end.Y;

                    y1hi = _start.Y;

                }

                else

                {

                    y1hi = _end.Y;

                    y1lo = _start.Y;

                }

                if (By > 0)

                {

                    if ((y1hi < line2d._end.Y) || (line2d._start.Y < y1lo)) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((y1hi < line2d._start.Y) || (line2d._end.Y < y1lo)) return ClipLine.DONT_INTERSECT;

                }

                Cx = _start.X - line2d._start.X;

                Cy = _start.Y - line2d._start.Y;

                f = Ay * Bx - Ax * By;	/* both denominator*/

                /// lines are collinear.

                if (0.0 == f) return ClipLine.COLLINEAR;

                d = By * Cx - Bx * Cy;	/* alpha numerator*/

                if (f > 0.0)

                {		/* alpha tests*/

                    if ((d < (0 + ClipLine.TOLER)) || (d > (f - ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((d > (0 - ClipLine.TOLER)) || (d < (f + ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                e = Ax * Cy - Ay * Cx;	/* beta numerator*/

                if (f > 0.0)

                {		/* beta tests*/

                    if ((e < (0 + ClipLine.TOLER)) || (e > (f - ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((e > (0 - ClipLine.TOLER)) || (e < (f + ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                /*compute intersection coordinates*/

                double alpha = d / f;

                if (_start.X == _end.X)

                    intsec.X = _start.X;

                else intsec.X = _start.X + alpha * Ax;

                if (_start.Y == _end.Y)

                    intsec.Y = _start.Y;

                else intsec.Y = _start.Y + alpha * Ay;

                return ClipLine.INTERSECT;

            }

        }

        public class ClipRect

        {

            public Point center;

            public double width, height, angle;	/// angle is degree

            public int IntersectWith(ref Point intsec, ClipLine line2d)

            {

                double radians = Math.PI * angle / 180.0;

                double cs = Math.Cos(radians), sn = Math.Sin(radians);

                Point[] corner = new Point[4];

                corner[0].X = center.X - width * 0.5;

                corner[0].Y = center.Y - height * 0.5;

                corner[1] = corner[0];

                corner[1].X += width;

                corner[2] = corner[1];

                corner[2].Y += height;

                corner[3] = corner[2];

                corner[3].X -= width;

                /// rotate 4 corners about angle

                for (int i = 0; i < corner.Length; ++i)

                {

                    double ptx = corner[i].X - center.X;

                    double pty = corner[i].Y - center.Y;

                    corner[i].X = center.X + ((cs * ptx) - (sn * pty));

                    corner[i].Y = center.Y + ((sn * ptx) + (cs * pty));

                }

                for (int i = 0; i < corner.Length; ++i)

                {

                    int si = i % corner.Length, ei = (i + 1) % corner.Length;

                    if (ClipLine.INTERSECT == line2d.IntersectWith(ref intsec, new ClipLine(corner[si], corner[ei])))

                    {

                        return ClipLine.INTERSECT;

                    }

                }

                return ClipLine.DONT_INTERSECT;

            }

        }

        public static double AngleMethod(Point StartPoint, Point EndPoint)

        {

            return Math.Abs(Math.Atan2(EndPoint.X - StartPoint.X, StartPoint.Y - EndPoint.Y) * Rad2Deg);

        }

        public static double DegreesToRadians(double angle)

        {

            return ((angle * Math.PI) / 180f);

        }

        //public static double AngleMethod(double px1, double py1, double px2, double py2)

        //{

        //    return Math.Abs(Math.Atan2(px2 - px1, py1 - py2) * Rad2Deg);

        //}

        public static double DistanceTo(Point p1, Point p2)

        {

            double dx = p2.X - p1.X;

            double dy = p2.Y - p1.Y;

            return Math.Sqrt(dx * dx + dy * dy);

        }

        public static Point getMiddlePoint(Point p1, Point p2)

        {

            return new Point { X = (p1.X + p2.X) / 2, Y = (p1.Y + p2.Y) / 2 };

        }

        /// <summary>

        /// return area of polygon

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2012.07.04</date>

        /// <param name="points"></param>

        /// <returns></returns>

        public static double AreaOf(List<Point> points)

        {

            double res = 0;

            int p = 0, q = 0;

            for (p = points.Count - 1, q = 0; q < points.Count; p = q++)

            {

                res += points[p].X * points[q].Y - points[p].Y * points[q].X;

            }

            return res;

        }

        /// <summary>

        /// return normal vector from p1 to p2

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2012.07.19</date>

        /// <param name="p1"></param>

        /// <param name="p2"></param>

        /// <returns></returns>

        public static Point GetNormVectorBetween(Point p1, Point p2)

        {

            Point res = new Point();

            double d = MathSet.DistanceTo(p1, p2);

            if (d > 0)

            {

                res.X = (p2.X - p1.X) / d;

                res.Y = (p2.Y - p1.Y) / d;

            }

            return res;

        }

        public static Point FindCentroid(List<Point> pntSet)

        {

            Double getThePointX = new Double();

            Double getThePointY = new Double();

            for (int i = 0; i < pntSet.Count; i++)

            {

                int ReIndex = (i + pntSet.Count / 2) % pntSet.Count;

                Point p = (MathSet.getMiddlePoint(pntSet[i], pntSet[ReIndex]));

                getThePointX += p.X;

                getThePointY += p.Y;

            }

            double count = Convert.ToDouble(pntSet.Count);

            //return new Point(getThePointX/Convert.ToDouble(pntSet.Count(),getThePointY/Convert.ToDouble(pntSet.Count());

            return new Point(getThePointX / count, getThePointY / count);

        }

        public static Point RotateAbout(Point org, Point dest, double dAngle)

        {

            double ptx = dest.X - org.X;

            double pty = dest.Y - org.Y;

            double radians = Math.PI * dAngle / 180.0;

            double pt1x = org.X + ((Math.Cos(radians) * ptx) - (Math.Sin(radians) * pty));

            double pt2x = org.Y + ((Math.Sin(radians) * ptx) + (Math.Cos(radians) * pty));

            return new Point(pt1x, pt2x);

        }

        public static double getAngle(double x1, double y1, double x2, double y2)

        {

            double alpha = 0;

            double dx = x2 - x1;

            double dy = y2 - y1;

            double l = Math.Sqrt(dx * dx + dy * dy);

            if (l > 0)

            {

                alpha = Math.Acos(dx / l);

                double cross = MathSet.CrossProduct(1, 0, dx, dy);

                if (cross < 0) alpha = -alpha;

                alpha *= MathSet.Rad2Deg;

            }

            else

            {

                alpha = 0;

            }

            return alpha;

        }

        public static double DotProduct(double x1, double y1, double x2, double y2)

        {

            return (x1 * x2 + y1 * y2);

        }

        public static double CrossProduct(double x1, double y1, double x2, double y2)

        {

            return (x1 * y2 - y1 * x2);

        }

        /// <summary>

        /// return angle in degree between given two vectors

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2018.05.09</date>

        /// <param name="vec1"></param>

        /// <param name="vec2"></param>

        /// <returns></returns>

        public static double getAngleBetweenVectors(Point vec1, Point vec2)

        {

            double dot = MathSet.DotProduct(vec1.X, vec1.Y, vec2.X, vec2.Y);

            double length1 = Math.Sqrt(vec1.X * vec1.X + vec1.Y * vec1.Y);

            double length2 = Math.Sqrt(vec2.X * vec2.X + vec2.Y * vec2.Y);

            double cross = MathSet.CrossProduct(vec1.X, vec1.Y, vec2.X, vec2.Y);

            double radian = Math.Acos(dot / (length1 * length2));

            return (cross > 0) ? radian * MathSet.Rad2Deg : -(radian * MathSet.Rad2Deg);

        }

        // 사용용도가 불분명함.

        public static string returnAngleString(Point start, ref Point end, bool PressShift)

        {

            double angle = MathSet.getAngle(start.X, start.Y, end.X, end.Y);

            double approxAngle = MathSet.getMultipleAngle(UnitAngle, angle);

            if (PressShift)

            {

                double distance = MathSet.DistanceTo(start, end);

                end = MathSet.RotateAbout(start, new Point(start.X + distance, start.Y), approxAngle);

                return String.Format("{1}({0})", approxAngle.ToString("0.#") + "°", Math.Abs(approxAngle - 360).ToString("0.#") + "°");

            }

            else

            {

                angle *= -1;

                if (angle < 0)

                {

                    angle = angle + 360;

                }

                return String.Format("{0}", angle.ToString("0.#") + "°");

            }

        }

        /// <summary>

        /// returnAngleString을 변경하여 수정

        /// 상단 컨트롤에 Angle값을 보여주기 위해 수정함.

        /// </summary>

        /// <param name="start"></param>

        /// <param name="end"></param>

        /// <param name="PressShift"></param>

        /// <returns></returns>

        public static double returnAngle(Point start, ref Point end, bool PressShift)

        {

            double angle = MathSet.getAngle(start.X, start.Y, end.X, end.Y);

            double approxAngle = MathSet.getMultipleAngle(UnitAngle, angle);

            if (PressShift)

            {

                double distance = MathSet.DistanceTo(start, end);

                end = MathSet.RotateAbout(start, new Point(start.X + distance, start.Y), approxAngle);

                angle = approxAngle;

            }

            return angle;

        }

        public static Point getRectMiddlePoint(Rect data)

        {

            Point startP = new Point(data.X, data.Y);

            Point endP = new Point(data.Right, data.Bottom);

            return MathSet.getMiddlePoint(startP, endP);

        }

    }

}