SANAS/Core/ScaleFactor.cs

using Resources;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SmartCoalApplication.Core
{
    /// <summary>
    /// 封装了缩放坐标的功能
    /// </summary>
    public struct ScaleFactor
    {
        /// <summary>
        /// 分母
        /// </summary>
        private int denominator;

        /// <summary>
        /// 分子
        /// </summary>
        private int numerator;

        public int Denominator
        {
            get
            {
                return denominator;
            }
        }

        public int Numerator
        {
            get
            {
                return numerator;
            }
        }

        /// <summary>
        /// 缩放比例
        /// </summary>
        public double Ratio
        {
            get
            {
                return (double)numerator / (double)denominator;
            }
        }

        public static readonly ScaleFactor OneToOne = new ScaleFactor(1, 1);
        public static readonly ScaleFactor MinValue = new ScaleFactor(1, 100);
        public static readonly ScaleFactor MaxValue = new ScaleFactor(32, 1);

        private void Clamp()
        {
            if (this < MinValue)
            {
                this = MinValue;
            }
            else if (this > MaxValue)
            {
                this = MaxValue;
            }
        }

        public static ScaleFactor UseIfValid(int numerator, int denominator, ScaleFactor lastResort)
        {
            if (numerator <= 0 || denominator <= 0)
            {
                return lastResort;
            }
            else
            {
                return new ScaleFactor(numerator, denominator);
            }
        }

        public static ScaleFactor Min(int n1, int d1, int n2, int d2, ScaleFactor lastResort)
        {
            ScaleFactor a = UseIfValid(n1, d1, lastResort);
            ScaleFactor b = UseIfValid(n2, d2, lastResort);
            return ScaleFactor.Min(a, b);
        }

        public static ScaleFactor Max(int n1, int d1, int n2, int d2, ScaleFactor lastResort)
        {
            ScaleFactor a = UseIfValid(n1, d1, lastResort);
            ScaleFactor b = UseIfValid(n2, d2, lastResort);
            return ScaleFactor.Max(a, b);
        }

        public static ScaleFactor Min(ScaleFactor lhs, ScaleFactor rhs)
        {
            if (lhs < rhs)
            {
                return lhs;
            }
            else
            {
                return rhs;
            }
        }

        public static ScaleFactor Max(ScaleFactor lhs, ScaleFactor rhs)
        {
            if (lhs > rhs)
            {
                return lhs;
            }
            else
            {
                return lhs;
            }
        }

        public static bool operator ==(ScaleFactor lhs, ScaleFactor rhs)
        {
            return (lhs.numerator * rhs.denominator) == (rhs.numerator * lhs.denominator);
        }

        public static bool operator !=(ScaleFactor lhs, ScaleFactor rhs)
        {
            return !(lhs == rhs);
        }

        public static bool operator <(ScaleFactor lhs, ScaleFactor rhs)
        {
            return (lhs.numerator * rhs.denominator) < (rhs.numerator * lhs.denominator);
        }

        public static bool operator <=(ScaleFactor lhs, ScaleFactor rhs)
        {
            return (lhs.numerator * rhs.denominator) <= (rhs.numerator * lhs.denominator);
        }

        public static bool operator >(ScaleFactor lhs, ScaleFactor rhs)
        {
            return (lhs.numerator * rhs.denominator) > (rhs.numerator * lhs.denominator);
        }

        public static bool operator >=(ScaleFactor lhs, ScaleFactor rhs)
        {
            return (lhs.numerator * rhs.denominator) >= (rhs.numerator * lhs.denominator);
        }

        public override bool Equals(object obj)
        {
            if (obj is ScaleFactor)
            {
                ScaleFactor rhs = (ScaleFactor)obj;
                return this == rhs;
            }
            else
            {
                return false;
            }
        }

        public override int GetHashCode()
        {
            return numerator.GetHashCode() ^ denominator.GetHashCode();
        }

        private static string percentageFormat = PdnResources.GetString("ScaleFactor.Percentage.Format");
        public override string ToString()
        {
            try
            {
                return string.Format(percentageFormat, unchecked(Math.Round(unchecked(100 * Ratio))));
            }

            catch (ArithmeticException)
            {
                return "--";
            }
        }

        public int ScaleScalar(int mul)
        {
            return (int)(((long)mul * numerator) / denominator);
        }

        public int UnscaleScalar(int mul)
        {
            return (int)(((long)mul * denominator) / numerator);
        }

        public float ScaleScalar(float mul)
        {
            return (mul * (float)numerator) / (float)denominator;
        }

        public float UnscaleScalar(float mul)
        {
            return (mul * (float)denominator) / (float)numerator;
        }

        public double ScaleScalar(double mul)
        {
            return (mul * (double)numerator) / (double)denominator;
        }

        public double UnscaleScalar(double mul)
        {
            return (mul * (double)denominator) / (double)numerator;
        }

        public Point ScalePoint(Point point)
        {
            return new Point(ScaleScalar(point.X), ScaleScalar(point.Y));
        }

        public PointF ScalePoint(PointF point)
        {
            return new PointF(ScaleScalar(point.X), ScaleScalar(point.Y));
        }

        public PointF ScalePointJustX(PointF point)
        {
            return new PointF(ScaleScalar(point.X), point.Y);
        }

        public PointF ScalePointJustY(PointF point)
        {
            return new PointF(point.X, ScaleScalar(point.Y));
        }

        public PointF UnscalePoint(PointF point)
        {
            return new PointF(UnscaleScalar(point.X), UnscaleScalar(point.Y));
        }

        public PointF UnscalePointJustX(PointF point)
        {
            return new PointF(UnscaleScalar(point.X), point.Y);
        }

        public PointF UnscalePointJustY(PointF point)
        {
            return new PointF(point.X, UnscaleScalar(point.Y));
        }

        public Point ScalePointJustX(Point point)
        {
            return new Point(ScaleScalar(point.X), point.Y);
        }

        public Point ScalePointJustY(Point point)
        {
            return new Point(point.X, ScaleScalar(point.Y));
        }

        public Point UnscalePoint(Point point)
        {
            return new Point(UnscaleScalar(point.X), UnscaleScalar(point.Y));
        }

        public Point UnscalePointJustX(Point point)
        {
            return new Point(UnscaleScalar(point.X), point.Y);
        }

        public Point UnscalePointJustY(Point point)
        {
            return new Point(point.X, UnscaleScalar(point.Y));
        }

        public SizeF ScaleSize(SizeF size)
        {
            return new SizeF(ScaleScalar(size.Width), ScaleScalar(size.Height));
        }

        public SizeF UnscaleSize(SizeF size)
        {
            return new SizeF(UnscaleScalar(size.Width), UnscaleScalar(size.Height));
        }

        public Size ScaleSize(Size size)
        {
            return new Size(ScaleScalar(size.Width), ScaleScalar(size.Height));
        }

        public Size UnscaleSize(Size size)
        {
            return new Size(UnscaleScalar(size.Width), UnscaleScalar(size.Height));
        }

        public RectangleF ScaleRectangle(RectangleF rectF)
        {
            return new RectangleF(ScalePoint(rectF.Location), ScaleSize(rectF.Size));
        }

        public RectangleF UnscaleRectangle(RectangleF rectF)
        {
            return new RectangleF(UnscalePoint(rectF.Location), UnscaleSize(rectF.Size));
        }

        public Rectangle ScaleRectangle(Rectangle rect)
        {
            return new Rectangle(ScalePoint(rect.Location), ScaleSize(rect.Size));
        }

        public Rectangle UnscaleRectangle(Rectangle rect)
        {
            return new Rectangle(UnscalePoint(rect.Location), UnscaleSize(rect.Size));
        }

        private static readonly double[] scales =
            {
                0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.08, 0.12, 0.16, 0.25, 0.33, 0.50, 0.66, 1,
                2, 3, 4, 5, 6, 7, 8, 12, 16, 24, 32
            };

        /// <summary>
        /// Gets a list of values that GetNextLarger() and GetNextSmaller() will cycle through.
        /// </summary>
        /// <remarks>
        /// 1.0 is guaranteed to be in the array returned by this property. This list is also
        /// sorted in ascending order.
        /// </remarks>
        public static double[] PresetValues
        {
            get
            {
                double[] returnValue = new double[scales.Length];
                scales.CopyTo(returnValue, 0);
                return returnValue;
            }
        }

        /// <summary>
        /// Rounds the current scaling factor up to the next power of two.
        /// </summary>
        /// <returns>The new ScaleFactor value.</returns>
        public ScaleFactor GetNextLarger()
        {
            double ratio = Ratio + 0.005;

            int index = Array.FindIndex(
                scales,
                delegate (double scale)
                {
                    return ratio <= scale;
                });

            if (index == -1)
            {
                index = scales.Length;
            }

            index = Math.Min(index, scales.Length - 1);

            return ScaleFactor.FromDouble(scales[index]);
        }

        public ScaleFactor GetNextSmaller()
        {
            double ratio = Ratio - 0.005;

            int index = Array.FindIndex(
                scales,
                delegate (double scale)
                {
                    return ratio <= scale;
                });

            --index;

            if (index == -1)
            {
                index = 0;
            }

            index = Math.Max(index, 0);

            return ScaleFactor.FromDouble(scales[index]);
        }

        private static ScaleFactor Reduce(int numerator, int denominator)
        {
            int factor = 2;

            while (factor < denominator && factor < numerator)
            {
                if ((numerator % factor) == 0 && (denominator % factor) == 0)
                {
                    numerator /= factor;
                    denominator /= factor;
                }
                else
                {
                    ++factor;
                }
            }

            return new ScaleFactor(numerator, denominator);
        }

        public static ScaleFactor FromDouble(double scalar)
        {
            int numerator = (int)(Math.Floor(scalar * 1000.0));
            int denominator = 1000;
            return Reduce(numerator, denominator);
        }

        public ScaleFactor(int numerator, int denominator)
        {
            if (denominator <= 0)
            {
                throw new ArgumentOutOfRangeException("denominator", "must be greater than 0");
            }

            if (numerator < 0)
            {
                throw new ArgumentOutOfRangeException("numerator", "must be greater than 0");
            }

            this.numerator = numerator;
            this.denominator = denominator;
            this.Clamp();
        }
    }
}