MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Media;

namespace KCOM.Common

{

    public static class MathHelper

    {

        public static Point RotatePoint(Point p1, Point p2, double angle)

        {

            //double radians = ConvertToRadians(angle);

            //double sin = Math.Sin(radians);

            //double cos = Math.Cos(radians);

            //// Translate point back to origin

            //p1.X -= p2.X;

            //p1.Y -= p2.Y;

            //// Rotate point

            //double xnew = p1.X * cos - p1.Y * sin;

            //double ynew = p1.X * sin + p1.Y * cos;

            //// Translate point back

            //Point newPoint = new Point((int)xnew + p2.X, (int)ynew + p2.Y);

            var transform = new RotateTransform() { Angle = angle, CenterX = p2.X, CenterY = p2.Y };

            var transformedPoint = transform.Transform(p1);

            return transformedPoint;

        }

        public static double ConvertToRadians(double angle)

        {

            return (Math.PI / 360) * angle;

        }

        public static Rect RotateRect(Rect rect,Point Center,double angle)

        {

            Rect rotateRect = rect;

            var centerPoint = new Point(rect.X + rect.Width,rect.Y + rect.Height);

            var rotationCenter = RotatePoint(centerPoint, Center, angle);

            if (angle == 270 || angle == 90)

            {

                rotateRect = new Rect(0,0, rect.Height, rect.Width);

            }

            else

            {

                rotateRect = new Rect(0,0, rect.Width, rect.Height);

            }

            rotateRect.X = rotationCenter.X;

            rotateRect.Y = rotationCenter.Y;

            rect.Transform(RotateAroundPoint(angle, Center));

            //var points = RectToPoints(rect).Select(x=> RotateAroundPoint(x,Center,angle));

            //var newtest = PointsToRect(points);

            return rect;

        }

        private static Matrix RotateAroundPoint(double angle, Point center)

        {

            // Translate the point to the origin.

            Matrix result = new Matrix();

            result.RotateAt(angle, center.X, center.Y);

            return result;

        }

        private static IEnumerable<Point> RectToPoints(Rect rect)

        {

            return new [] { rect.TopLeft, rect.TopRight, rect.BottomLeft, rect.BottomRight };

        }

        private static Rect PointsToRect(IEnumerable<Point> points)

        {

            return new Rect(points.ToArray()[0],points.ToArray()[3]);

        }

        public static Rect CombineRects(List<Rect> rects)

        {

            if (rects == null || rects.Count == 0)

                throw new ArgumentException("Rect list must not be null or empty.");

            if (rects.Count == 1)

                return rects[0];

            // 초기화를 위해 첫 번째 Rect를 사용합니다.

            double minX = rects[0].Left;

            double minY = rects[0].Top;

            double maxX = rects[0].Right;

            double maxY = rects[0].Bottom;

            // 모든 Rect를 반복하면서 최소 및 최대 좌표를 찾습니다.

            foreach (Rect rect in rects)

            {

                minX = Math.Min(minX, rect.Left);

                minY = Math.Min(minY, rect.Top);

                maxX = Math.Max(maxX, rect.Right);

                maxY = Math.Max(maxY, rect.Bottom);

            }

            // 계산된 최소 및 최대 좌표를 사용하여 새로운 Rect를 생성합니다.

            double width = maxX - minX;

            double height = maxY - minY;

            return new Rect(minX, minY, width, height);

        }

    }

}