Polygon.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.game.geom;
 
import de.lathanda.eos.base.Picture;
import de.lathanda.eos.base.math.Matrix;
import de.lathanda.eos.base.math.Point;
import de.lathanda.eos.base.math.Vector;
 
public class Polygon extends Shape {
 
    /* package */
    double[] coordinates_x;
    /* package */
    double[] coordinates_y;
    /* package */
    double[] coordinates_final_x;
    /* package */
    double[] coordinates_final_y;
    /* package */
    int n;
 
    protected Polygon() {
        p = new Point(0, 0);
    }
 
    public Polygon(double[] x, double[] y) {
        p = new Point(0, 0);
        setVertices(x, y);
    }
 
    public Polygon(Polygon poly) {
        p = new Point(poly.p);
        angle = poly.angle;
        setVertices(poly.coordinates_x, poly.coordinates_y);
    }
 
    public final void setVertices(double[] x, double[] y) {
        n = x.length;
        coordinates_x = new double[n];
        coordinates_y = new double[n];
        Vector previous = new Vector(x[0] - x[n - 1], y[0] - y[n - 1]);
        Vector actual;
        for (int i = 0; i < n; i++) {
            coordinates_x[i] = x[i];
            coordinates_y[i] = y[i];
        }
        int j; // next point
        for (int i = 0; i < n; i++) {
            j = (i + 1) % n;
            actual = new Vector(coordinates_x[j] - coordinates_x[i],
                    coordinates_y[j] - coordinates_y[i]);
            if (previous.crossproduct(actual) > 0) {
                throw new ConcaveCornerRuntimeException(i,
                        new Point(coordinates_x[(i - 1 + n) % n], coordinates_y[(i - 1 + n) % n]),
                        new Point(coordinates_x[i], coordinates_y[i]),
                        new Point(coordinates_x[j], coordinates_y[j]));
            }
            previous = actual;
        }
        coordinates_final_x = new double[n];
        coordinates_final_y = new double[n];
        transform();
    }
 
    protected Types getOutlineType() {
        return Types.POLYGON;
    }
 
    private void transform() {
        if (coordinates_x == null) {
            return;
        }
 
        Matrix m = new Matrix(p.getX(), p.getY(), angle, 1, 1);
        m.transform(coordinates_x, coordinates_y, coordinates_final_x,
                coordinates_final_y);
        right = Double.NEGATIVE_INFINITY;
        left = Double.POSITIVE_INFINITY;
        top = Double.NEGATIVE_INFINITY;
        bottom = Double.POSITIVE_INFINITY;
        for (int i = 0; i < n; i++) {
            if (coordinates_final_x[i] < left) {
                left = coordinates_final_x[i];
            }
            if (coordinates_final_x[i] > right) {
                right = coordinates_final_x[i];
            }
            if (coordinates_final_y[i] < bottom) {
                bottom = coordinates_final_y[i];
            }
            if (coordinates_final_y[i] > top) {
                top = coordinates_final_y[i];
            }
        }
    }
 
    @Override
    public boolean contains(double x, double y) {
        Vector v;
        Vector w;
        for (int i = 0, j; i < n; i++) {
            j = (i + 1) % n;
            v = new Vector(coordinates_final_x[j] - coordinates_final_x[i],
                    coordinates_final_y[j] - coordinates_final_y[i]);
            w = new Vector(x - coordinates_final_x[i], y
                    - coordinates_final_y[i]);
            if (v.crossproduct(w) > 0) {
                return false;
            }
        }
        return true;
    }
 
    @Override
    public double getDistance(double x, double y) {
        Vector v;
        Vector w;
        double distance = Double.POSITIVE_INFINITY;
        double edgeDistance = 0;
        double projection = 0;
        boolean within = true;
        for (int i = 0, j; i < n; i++) {
            j = (i + 1) % n;
            v = new Vector(coordinates_final_x[j] - coordinates_final_x[i],
                    coordinates_final_y[j] - coordinates_final_y[i]);
            w = new Vector(x - coordinates_final_x[i],
                    y - coordinates_final_y[i]);
            edgeDistance = w.getPerpendicularLength(v);
            projection = w.getProjectionLength(v);
 
            if (edgeDistance > 0) {
                within = false;
            } else {
                edgeDistance = -edgeDistance;
            }
            distance = Math.min(distance, w.getLength());
            if (0 < projection && projection < v.getLength()) {
                distance = Math.min(distance, edgeDistance);
            }
        }
        return (within) ? -distance : distance;
    }
 
    protected void positionChanged() {
        transform();
    }
 
    protected void angleChanged() {
        transform();
    }
 
    @Override
    public void draw(Picture picture) {
        picture.drawPolygon(coordinates_final_x, coordinates_final_y);
        
    }
}