source: trunk/src/org/expeditee/core/Point.java@ 1097

package org.expeditee.core;

/**
 * Represents a (x,y)-coordinate in 2-dimensional space.
 * Coordinates are integral.
 * 
 * @author cts16
 */
public class Point {
        
        /** The origin of the coordinate system. */
        public static final Point ORIGIN = new Point(0, 0);
        
        /** The x-coordinate of this point. */
        public int x;
        /** The y-coordinate of this point. */
        public int y;
        
        /** Default constructor creates a point at the origin. */
        public Point()
        {
                this(0, 0);
        }
        
        /** Standard constructor. */
        public Point(int x, int y)
        {
                set(x, y);
        }
        
        /** Convenience constructor automatically casts floats to ints. */
        public Point(float x, float y)
        {
                this((int) x, (int) y);
        }
        
        /** Copy constructor. */
        public Point(Point other)
        {
                this();
                set(other);
        }
        
        /** Sets the position of the point. */
        public Point set(int x, int y)
        {
                this.x = x;
                this.y = y;
                return this;
        }
        
        /** Sets the position of this point to be the same as the given point.
            If p is null, no change is made. */
        public Point set(Point p)
        {
                if (p != null) set(p.x, p.y);
                return this;
        }
        
        /** Moves the point by the given amount in each dimension. */
        public Point add(int x, int y)
        {
                this.x += x;
                this.y += y;
                return this;
        }
        
        /** Moves the point by the given amount in each dimension.
            Doubles are automatically cast to ints. */
        public Point add(double x, double y)
        {
                return add((int) x, (int) y);
        }
        
        /** Adds the coordinates of the given point to this point's coordinates
            (treating points as vectors). */
        public Point add(Point p)
        {
                 if (p != null) add(p.x, p.y);
                 return this;
        }
        
        /**
         * Rotates this point around another point.
         * 
         * @param angle
         *              The angle to rotate through (clockwise, in radians).
         * 
         * @param x
         *              The x-coordinate of the centre of rotation.
         * 
         * @param y
         *              The y-coordinate of the centre of rotation.
         */
        public Point rotate(double angle, int x, int y)
        {
                // Find the distance from this point to the centre of rotation
                // (should stay the same during rotation)
                double length = Point.distanceBetween(x, y, this.x, this.y);
                
                // Find the starting elevation angle of this point relative to
                // the centre of rotation.
                double startingAngle = Math.atan2(this.y - y, this.x - x);
                
                // Increase/decrease the elevation angle by the given amount 
                double finalAngle = startingAngle + angle;
                
                // Calculate the point at the same distance from the centre of rotation
                // elevated at the new angle.
                this.x = (int) (x + length * Math.cos(finalAngle));
                this.y = (int) (y + length * Math.sin(finalAngle));
                
                return this;
        }
        
        /**
         * Rotates this point around another point.
         * 
         * @param angle
         *              The angle to rotate through (clockwise, in radians).
         * 
         * @param cor
         *              The centre of rotation.
         */
        public Point rotate(double angle, Point cor)
        {
                if (cor != null) rotate(angle, cor.x, cor.y);
                return this;
        }
        
        /** Gets the distance from this point to another point. */
        public double getDistanceTo(Point other)
        {
                return distanceBetween(this, other);
        }
        
        /** Gets the distance between two points. */
        public static double distanceBetween(Point p1, Point p2)
        {
                if (p1 == null || p2 == null) return 0.0;
                
                return distanceBetween(p1.x, p1.y, p2.x, p2.y);
        }

        /** Gets the distance between two points specified by their coordinates. */
        public static double distanceBetween(int x1, int y1, int x2, int y2)
        {
                double x = x1 - x2;
                double y = y1 - y2;
                return Math.sqrt(x * x + y * y);
        }
        
        @Override
        public boolean equals(Object other)
        {
                if (other instanceof Point) {
                        Point p = (Point) other;
                        return this.x == p.x && this.y == p.y;
                }
                return false;
        }

        /** Gets the x-coordinate of this point. */
        public int getX()
        {
                return x;
        }
        
        /** Gets the y-coordinate of this point. */
        public int getY()
        {
                return y;
        }
        
        @Override
        public Point clone()
        {
                return new Point(this);
        }
        
        /** Gets a point representing the difference between the two given points
            (returned point should be treated as a vector). */
        public static Point difference(Point p1, Point p2)
        {
                if (p1 == null || p2 == null) return null;
                return new Point(p1.x - p2.x, p1.y - p2.y);
        }
        
        /** Calculates the dot-product between two lines that share a common point. */
        public static double dotProduct(Point commonPoint, Point lineEnd1, Point lineEnd2)
        {
                if (commonPoint == null || lineEnd1 == null || lineEnd2 == null) return 0.0;
                
                Point p1 = new Point(lineEnd1.x - commonPoint.x, lineEnd1.y - commonPoint.y);
                Point p2 = new Point(lineEnd2.x - commonPoint.x, lineEnd2.y - commonPoint.y);
                return p1.x * p2.x + p1.y * p2.y;
        }
        
        @Override
        public String toString()
        {
                return "(" + x + ", " + y + ")";
        }
}