bbiwarg-original/bbiwarg/Utility/Vector2D.cs

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

namespace bbiwarg.Utility
{
    class Vector2D
    {
        private float x;
        private float y;
        private float length;
        public float X { get { return x; } private set { x = value; } }
        public float Y { get { return y; } private set { y = value; } }
        public float Length { get { return length; } private set { length = value; } }

        public Vector2D(float x, float y) {
            setXY(x, y);
        }

        public Vector2D(Point point) {
            setXY(point.X, point.Y);
        }

        public Vector2D(PointF point)
        {
            setXY(point.X, point.Y);
        }

        public static implicit operator PointF(Vector2D vec)
        {
            return new PointF(vec.X, vec.Y);
        }

        private void setXY(float x, float y) {
            X = x;
            Y = y;
            Length = (float)Math.Sqrt(X * X + Y * Y);
        }

        public float getDistanceTo(Vector2D point) {
            return (this - point).Length;
        }

        public float getAngleBetween(Vector2D vector) {
            return (float)Math.Acos(dotProduct(vector) / (Length * vector.Length));
        }

        public float dotProduct(Vector2D vector) {
            return X * vector.X + Y * vector.Y;
        }

        public bool isInBox(Vector2D corner1, Vector2D corner2) {
            float minX = Math.Min(corner1.X, corner2.X);
            float maxX = Math.Max(corner1.X, corner2.X);
            float minY = Math.Min(corner1.Y, corner2.Y);
            float maxY = Math.Max(corner1.Y, corner2.Y);
            return (minX <= X && X <= maxX && minY <= Y && Y <= maxY);
        }

        public Vector2D normalize() {
            return new Vector2D(X / Length, Y / Length);
        }

        public override string ToString()
        {
            return "(" + X + ", " + Y + ")";
        }

        public static Vector2D operator *(float scalar, Vector2D vector)
        {
            return new Vector2D(scalar * vector.X, scalar * vector.Y);
        }

        public static Vector2D operator *(Vector2D vector, float scalar)
        {
            return new Vector2D(scalar * vector.X, scalar * vector.Y);
        }

        public static Vector2D operator /(Vector2D vector, float scalar)
        {
            return new Vector2D(vector.X / scalar, vector.Y / scalar);
        }

        public static Vector2D operator +(Vector2D vector1, Vector2D vector2)
        {
            return new Vector2D(vector1.X + vector2.X, vector1.Y + vector2.Y);
        }

        public static Vector2D operator -(Vector2D vector1, Vector2D vector2)
        {
            return new Vector2D(vector1.X - vector2.X, vector1.Y - vector2.Y);
        }

        public float cross(Vector2D v)
        {
            return X * v.Y - Y * v.X;
        }

        public static Vector2D mean(List<Vector2D> vectors) {
            Vector2D meanVector = new Vector2D(0,0);
            foreach (Vector2D vector in vectors) {
                meanVector += vector;
            }
            return meanVector / vectors.Count;
        }

    }
}