Vector.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.base.math;
 
import de.lathanda.eos.base.Picture;
 
import java.text.MessageFormat;
 
public class Vector {
 
    public static Vector ZERO = new Vector(0, 0);
    public static Vector BASE1 = new Vector(1, 0);
    public static Vector BASE2 = new Vector(0, 1);
    private final double dX;
    private final double dY;
 
    public Vector(double dX, double dY) {
        this.dX = dX;
        this.dY = dY;
    }
 
    public Vector(Point p) {
        this.dX = p.getX();
        this.dY = p.getY();
    }
 
    public Vector(double angle) {
        dX = Math.cos(angle);
        dY = Math.sin(angle);
    }
 
    public Vector(Point A, Point B) {
        dX = B.getX() - A.getX();
        dY = B.getY() - A.getY();
    }
 
    public Vector(Vector v) {
        dX = v.dX;
        dY = v.dY;
    }
 
    public Vector multiply(double k) {
        return new Vector(dX * k, dY * k);
    }
 
    public Vector negative() {
        return new Vector(-dX, -dY);
    }
 
    public double getLength() {
        return Math.sqrt(dX * dX + dY * dY);
    }
    public double getSquareLength() {
        return dX * dX + dY * dY;
    }
 
    public Vector setLength(double l) {
        if (l == 0) {
            return ZERO;
        } else {
            return normalize().multiply(l);
        }
    }
 
    public double getdx() {
        return dX;
    }
 
    public double getdy() {
        return dY;
    }
    public Vector setdx(double newdx) {
        return new Vector(newdx, dY);
    }
    public Vector setdy(double newdy) {
        return new Vector(dX, newdy);
    }    
    public Point asPoint() {
        return new Point(dX,dY);
    }
    public Vector add(Vector v) {
        return new Vector(dX + v.dX, dY + v.dY);
    }
 
    public Vector substract(Vector v) {
        return new Vector(dX - v.dX, dY - v.dY);
    }
 
    public Vector substract(double dx, double dy) {
        return new Vector(this.dX - dx, this.dY - dy);
    }
    public Vector add(double x, double y) {
        return new Vector(dX + x, dY + y);
    }
 
    public double getAngle() {
        if (dX == 0) {
            if (dY < 0) {
                return 1.5* Math.PI;
            } else if (dY > 0) {
                return 0.5 * Math.PI;
            } else {
                return Double.NaN;
            }
        } else {
            double angle = Math.atan(dY / dX);
            if (dX < 0) {
                angle += Math.PI;
            }
            if (angle < 0) {
                angle += 2*Math.PI;
            }
            return angle;
        }
    }
    public double getAngleOrdernumber() {
        if (dX > 0) {
            if (dY >= 0) {
                return     dY / (dX + dY); //++
            } else {
                return 3 + dX / (dX - dY); //+-
            }
        } else {
            if (dY > 0) {
                return 1 + dX / (dX - dY); //-+             
            } else {
                return 2 + dY / (dX + dY); //--             
            }
        }
    }
 
    public Vector rotate(double dAngle) {
        double length = getLength();
        if (length == 0) {
            return this;
        }
        double angle = getAngle();
        angle += dAngle;
        return new Vector(length * Math.cos(angle), length * Math.sin(angle));
    }
    public Vector invertX() {
        return new Vector(-dX,dY);
    }
    public Vector invertY() {
        return new Vector(dX,-dY);
    }
   
    public double dotProduct(Vector b) {
        return dX * b.dX + dY * b.dY;
    }
 
    public double dotProduct(double x, double y) {
        return dX * x + dY * y;
    }
 
    public Vector normalize() {
        double n = getLength();
        if (n == 0) {
            return Vector.ZERO;
        } else {
            return new Vector(dX / n, dY / n);
        }
    }
 
    public Vector rotateRightAngleCounterClockwise() {
        return new Vector(-dY, dX);
    }
 
    public double getPerpendicularLength(Vector base) {
        double length = base.getLength();
        if (length == 0) {
            return getLength();
        } else {
            return -crossproduct(base) / length;
        }
    }
 
    public double getProjectionLength(Vector base) {
        double length = base.getLength();
        if (length == 0) {
            return 0;
        } else {
            return dotProduct(base) / length;
        }
    }
 
    public double getParallelogramArea(Vector a) {
        return Math.abs(crossproduct(a));
    }
 
    public double crossproduct(Vector b) {
        return  dX * b.dY - dY * b.dX;
    }
 
    public Vector getPerpendicular(Vector base) {
        return base.rotateRightAngleCounterClockwise().setLength(getPerpendicularLength(base));
    }
 
    public boolean isZero() {
        return dX == 0 && dY == 0;
    }
 
    @Override
    public String toString() {
        return MessageFormat.format("({0,number,#.00}|{1,number,#.00})",
                new Object[]{dX, dY});
    }
 
    public Vector getProjection(Vector base) {
        Vector b = base.normalize();
        return b.multiply(dotProduct(b));
    }
 
    public Vector addLength(double l) {
        double actL = getLength();
        if (actL + l <= 0.0 || actL == 0) {
            return ZERO;
        } else {
            return multiply((actL + l) / actL);
        }
    }
 
    public Vector restrict(double min, double max) {
        double len = getLength();
        if (len < min) {
            return setLength(min);
        }
        if (len > max) {
            return setLength(max);
        }
        return this;
    }
 
    public void render(Picture g, Point p, double scale, double arrowLength) {
        /*               this
         *               --->           HHH    |
         * 2* lineDiff | LLLLLLLLLLLLLLLHHHHHH | 2*headDiff
         *                              HHH    | headDiff = 3*lineDiff
         *               -------------->
         *                 headBase
         *               -------------------->
         *                 v = scale * this
         */
        Vector v = multiply(scale);
        double length = Math.min(v.getLength(), arrowLength);
        Point head = new Point(p);
        head.move(v);
        Vector headLength = v.setLength(-length);
        Vector headBreadth = v.setLength(length / 4d).rotateRightAngleCounterClockwise();
        Vector lineBreadth = headBreadth.multiply(1d / 3d);
        double[] x = new double[7];
        double[] y = new double[7];
        // all vectors are known, now we follow the vector chain
        Vector point = new Vector(head.getX(), head.getY());
        x[0] = point.getdx();
        y[0] = point.getdy();
        point = point.add(headLength).add(headBreadth);
        x[1] = point.getdx();
        y[1] = point.getdy();
        point = point.substract(headBreadth).substract(headBreadth);
        x[6] = point.getdx();
        y[6] = point.getdy();
        point = point.add(headBreadth).add(lineBreadth);
        x[2] = point.getdx();
        y[2] = point.getdy();
        point = point.substract(lineBreadth).substract(lineBreadth);
        x[5] = point.getdx();
        y[5] = point.getdy();
        point = new Vector(p.getX(), p.getY());
        point = point.add(lineBreadth);
        x[3] = point.getdx();
        y[3] = point.getdy();
        point = point.substract(lineBreadth).substract(lineBreadth);
        x[4] = point.getdx();
        y[4] = point.getdy();
        g.drawPolygon(x, y);
    }
}