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

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. */
        private int x;
        /** The y-coordinate of this point. */
        private 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.setX(x);
                this.setY(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.getX(), p.getY());
                return this;
        }

        /** Moves the point by the given amount in each dimension. */
        public Point add(int x, int y) {
                this.setX(this.getX() + x);
                this.setY(this.getY() + 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.getX(), p.getY());
                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.getX(), this.getY());

                // Find the starting elevation angle of this point relative to
                // the centre of rotation.
                double startingAngle = Math.atan2(this.getY() - y, this.getX() - 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.setX((int) (x + length * Math.cos(finalAngle)));
                this.setY((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.getX(), cor.getY());
                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.getX(), p1.getY(), p2.getX(), p2.getY());
        }

        /** 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.getX() == p.getX() && this.getY() == p.getY();
                }
                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.getX() - p2.getX(), p1.getY() - p2.getY());
        }

        /** 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.getX() - commonPoint.getX(), lineEnd1.getY() - commonPoint.getY());
                Point p2 = new Point(lineEnd2.getX() - commonPoint.getX(), lineEnd2.getY() - commonPoint.getY());
                return p1.getX() * p2.getX() + p1.getY() * p2.getY();
        }

        @Override
        public String toString() {
                return "(" + getX() + ", " + getY() + ")";
        }

        public void setY(int y) {
                this.y = y;
        }

        public void setX(int x) {
                this.x = x;
        }
}