Transform.java

Go to the documentation of this file.

 
package eu.mihosoft.vrl.v3d;
 
import javax.vecmath.Matrix4d;
import javax.vecmath.Quat4d;
 
// TODO: Auto-generated Javadoc
public class Transform {
 
    private final Matrix4d m;
 
    public Transform() {
        m = new Matrix4d();
        getInternalMatrix().m00 = 1;
        getInternalMatrix().m11 = 1;
        getInternalMatrix().m22 = 1;
        getInternalMatrix().m33 = 1;
    }
 
    public static Transform unity() {
        return new Transform();
    }
 
    public Transform(Matrix4d m) {
        this.m = m;
    }
 
    public Transform rotX(double degrees) {
        double radians = degrees * Math.PI * (1.0 / 180.0);
        double cos = Math.cos(radians);
        double sin = Math.sin(radians);
        double elemenents[] = { 1, 0, 0, 0, 0, cos, sin, 0, 0, -sin, cos, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform rotY(double degrees) {
        double radians = degrees * Math.PI * (1.0 / 180.0);
        double cos = Math.cos(radians);
        double sin = Math.sin(radians);
        double elemenents[] = { cos, 0, -sin, 0, 0, 1, 0, 0, sin, 0, cos, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform rotZ(double degrees) {
        double radians = degrees * Math.PI * (1.0 / 180.0);
        double cos = Math.cos(radians);
        double sin = Math.sin(radians);
        double elemenents[] = { cos, sin, 0, 0, -sin, cos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform rot(double x, double y, double z) {
        return rotX(x).rotY(y).rotZ(z);
    }
 
    public Transform rot(Vector3d vec) {
 
        // TODO: use quaternions
        return rotX(vec.x).rotY(vec.y).rotZ(vec.z);
    }
 
    public Transform translate(Vector3d vec) {
        return translate(vec.x, vec.y, vec.z);
    }
 
    public Transform translate(double x, double y, double z) {
        double elemenents[] = { 1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform translateX(double value) {
        double elemenents[] = { 1, 0, 0, value, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    // rotations
    public double getQuataurionX() {
        Matrix4d rotation = getInternalMatrix();
        Quat4d q1 = new Quat4d();
        rotation.get(q1);
 
        return q1.x;
    }
 
    public double getQuataurionY() {
        Matrix4d rotation = getInternalMatrix();
        Quat4d q1 = new Quat4d();
        rotation.get(q1);
 
        return q1.y;
    }
 
    public double getQuataurionZ() {
        Matrix4d rotation = getInternalMatrix();
        Quat4d q1 = new Quat4d();
        rotation.get(q1);
 
        return q1.z;
    }
 
    public double getQuataurionW() {
        Matrix4d rotation = getInternalMatrix();
        Quat4d q1 = new Quat4d();
        rotation.get(q1);
 
        return q1.w;
    }
 
    // translations
    public double getX() {
        javax.vecmath.Vector3d t1 = new javax.vecmath.Vector3d();
        getInternalMatrix().get(t1);
        return t1.x;
    }
 
    public double getY() {
        javax.vecmath.Vector3d t1 = new javax.vecmath.Vector3d();
        getInternalMatrix().get(t1);
        return t1.y;
    }
 
    public double getZ() {
        javax.vecmath.Vector3d t1 = new javax.vecmath.Vector3d();
        getInternalMatrix().get(t1);
        return t1.z;
    }
 
    /*
     * (non-Javadoc)
     * 
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        javax.vecmath.Vector3d t1 = new javax.vecmath.Vector3d();
        getInternalMatrix().get(t1);
        Quat4d q1 = new Quat4d();
        getInternalMatrix().get(q1);
        
        return "X="+t1.x+" Y="+t1.y+" Z="+t1.z+" Qx="+ q1.x+" Qy="+q1.y+" Qz="+q1.z+" Qw="+q1.w;
    }
 
 
    public Transform translateY(double value) {
        double elemenents[] = { 1, 0, 0, 0, 0, 1, 0, value, 0, 0, 1, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform translateZ(double value) {
        double elemenents[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, value, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform mirror(Plane plane) {
 
        System.err.println("WARNING: I'm too dumb to implement the mirror() operation correctly. Please fix me!");
 
        double nx = plane.normal.x;
        double ny = plane.normal.y;
        double nz = plane.normal.z;
        double w = plane.dist;
        double elemenents[] = { (1.0 - 2.0 * nx * nx), (-2.0 * ny * nx), (-2.0 * nz * nx), 0, (-2.0 * nx * ny),
                (1.0 - 2.0 * ny * ny), (-2.0 * nz * ny), 0, (-2.0 * nx * nz), (-2.0 * ny * nz), (1.0 - 2.0 * nz * nz),
                0, (-2.0 * nx * w), (-2.0 * ny * w), (-2.0 * nz * w), 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform scale(Vector3d vec) {
 
        if (vec.x == 0 || vec.y == 0 || vec.z == 0) {
            throw new IllegalArgumentException("scale by 0 not allowed!");
        }
 
        double elemenents[] = { vec.x, 0, 0, 0, 0, vec.y, 0, 0, 0, 0, vec.z, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform scale(double x, double y, double z) {
 
        if (x == 0 || y == 0 || z == 0) {
            throw new IllegalArgumentException("scale by 0 not allowed!");
        }
 
        double elemenents[] = { x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform scale(double s) {
 
        if (s == 0) {
            throw new IllegalArgumentException("scale by 0 not allowed!");
        }
 
        double elemenents[] = { s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform scaleX(double s) {
 
        if (s == 0) {
            throw new IllegalArgumentException("scale by 0 not allowed!");
        }
 
        double elemenents[] = { s, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform scaleY(double s) {
 
        if (s == 0) {
            throw new IllegalArgumentException("scale by 0 not allowed!");
        }
 
        double elemenents[] = { 1, 0, 0, 0, 0, s, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Transform scaleZ(double s) {
 
        if (s == 0) {
            throw new IllegalArgumentException("scale by 0 not allowed!");
        }
 
        double elemenents[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, s, 0, 0, 0, 0, 1 };
        getInternalMatrix().mul(new Matrix4d(elemenents));
        return this;
    }
 
    public Vector3d transform(Vector3d vec) {
        double x, y;
        x = getInternalMatrix().m00 * vec.x + getInternalMatrix().m01 * vec.y + getInternalMatrix().m02 * vec.z
                + getInternalMatrix().m03;
        y = getInternalMatrix().m10 * vec.x + getInternalMatrix().m11 * vec.y + getInternalMatrix().m12 * vec.z
                + getInternalMatrix().m13;
        vec.z = getInternalMatrix().m20 * vec.x + getInternalMatrix().m21 * vec.y + getInternalMatrix().m22 * vec.z
                + getInternalMatrix().m23;
        vec.x = x;
        vec.y = y;
 
        return vec;
    }
 
    public Vector3d transform(Vector3d vec, double amount) {
 
        double prevX = vec.x;
        double prevY = vec.y;
        double prevZ = vec.z;
 
        final double x, y;
        x = getInternalMatrix().m00 * vec.x + getInternalMatrix().m01 * vec.y + getInternalMatrix().m02 * vec.z
                + getInternalMatrix().m03;
        y = getInternalMatrix().m10 * vec.x + getInternalMatrix().m11 * vec.y + getInternalMatrix().m12 * vec.z
                + getInternalMatrix().m13;
        vec.z = getInternalMatrix().m20 * vec.x + getInternalMatrix().m21 * vec.y + getInternalMatrix().m22 * vec.z
                + getInternalMatrix().m23;
        vec.x = x;
        vec.y = y;
 
        double diffX = vec.x - prevX;
        double diffY = vec.y - prevY;
        double diffZ = vec.z - prevZ;
 
        vec.x = prevX + (diffX) * amount;
        vec.y = prevY + (diffY) * amount;
        vec.z = prevZ + (diffZ) * amount;
 
        return vec;
    }
 
    // // Multiply a CSG.Vector3D (interpreted as 3 column, 1 row) by this matrix
    // // (result = v*M)
    // // Fourth element is taken as 1
    // leftMultiply1x3Vector: function(v) {
    // var v0 = v._x;
    // var v1 = v._y;
    // var v2 = v._z;
    // var v3 = 1;
    // var x = v0 * this.elements[0] + v1 * this.elements[4] + v2 * this.elements[8]
    // + v3 * this.elements[12];
    // var y = v0 * this.elements[1] + v1 * this.elements[5] + v2 * this.elements[9]
    // + v3 * this.elements[13];
    // var z = v0 * this.elements[2] + v1 * this.elements[6] + v2 *
    // this.elements[10] + v3 * this.elements[14];
    // var w = v0 * this.elements[3] + v1 * this.elements[7] + v2 *
    // this.elements[11] + v3 * this.elements[15];
    // // scale such that fourth element becomes 1:
    // if(w != 1) {
    // var invw = 1.0 / w;
    // x *= invw;
    // y *= invw;
    // z *= invw;
    // }
    // return new CSG.Vector3D(x, y, z);
    // },
    public double getScale() {
        return getInternalMatrix().getScale();
    }
 
    public boolean isMirror() {
        return getInternalMatrix().determinant() < 0;
    }
 
    public Transform apply(Transform t) {
        getInternalMatrix().mul(t.getInternalMatrix());
        return this;
    }
 
 
    public Matrix4d getInternalMatrix() {
        return m;
    }
 
    public Transform inverse() {
        Transform tr = new Transform().apply(this);
 
        tr.getInternalMatrix().invert();
 
        return tr;
    }
 
    public Transform invert() {
        getInternalMatrix().invert();
 
        return this;
    }
    
    public Transform move(Number x, Number y, Number z) {
        return new Transform().translate(x.doubleValue(),y.doubleValue(),z.doubleValue()).apply(this);
    }
    public Transform move(Vertex v) {
        return new Transform().translate(v.getX(),v.getY(),v.getZ()).apply(this);
    }
    public Transform move(Vector3d v) {
        return new Transform().translate(v.x,v.y,v.z).apply(this);
    }
    public Transform move(Number[] posVector) {
        return move(posVector[0], posVector[1], posVector[2]);
    }
 
    // Helper/wrapper functions for movement
    public Transform movey(Number howFarToMove) {
        return new Transform().translateY(howFarToMove.doubleValue()).apply(this);
    }
 
    public Transform movez(Number howFarToMove) {
        return new Transform().translateZ(howFarToMove.doubleValue()).apply(this);
    }
 
    public Transform movex(Number howFarToMove) {
        return new Transform().translateX(howFarToMove.doubleValue()).apply(this);
    }
    
    // Helper/wrapper functions for movement
    public Transform mirrory() {
        return this.scaleY(-1);
    }
 
    public Transform mirrorz() {
        return this.scaleZ(-1);
    }
 
    public Transform mirrorx() {
        return this.scaleX(-1);
    }
 
    // Rotation function, rotates the object
    public Transform rotz(Number degreesToRotate) {
        return new Transform().rotZ(degreesToRotate.doubleValue()).apply(this);
    }
 
    public Transform roty(Number degreesToRotate) {
        return new Transform().rotY(degreesToRotate.doubleValue()).apply(this);
    }
 
    public Transform rotx(Number degreesToRotate) {
        return new Transform().rotX(degreesToRotate.doubleValue()).apply(this);
    }
 
}