eu.mihosoft.vrl.v3d.Transform Maven / Gradle / Ivy
/**
* Transform.java
*
* Copyright 2014-2014 Michael Hoffer . All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY Michael Hoffer "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Michael Hoffer OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* The views and conclusions contained in the software and documentation are
* those of the authors and should not be interpreted as representing official
* policies, either expressed or implied, of Michael Hoffer
* .
*/
package eu.mihosoft.vrl.v3d;
import javax.vecmath.Matrix4d;
/**
* Transform. Transformations (translation, rotation, scale) can be applied to
* geometrical objects like {@link CSG}, {@link Polygon}, {@link Vertex} and
* {@link Vector3d}.
*
* This transform class uses the builder pattern to define combined
* transformations.
*
* Example:
*
*
* // t applies rotation and translation
* Transform t = Transform.unity().rotX(45).translate(2,1,0);
*
*
* TODO: use quaternions for rotations.
*
* @author Michael Hoffer <[email protected]>
*/
public class Transform {
/**
* Internal 4x4 matrix.
*/
private final Matrix4d m;
/**
* Constructor.
*
* Creates a unit transform.
*/
public Transform() {
m = new Matrix4d();
m.m00 = 1;
m.m11 = 1;
m.m22 = 1;
m.m33 = 1;
}
/**
* Returns a new unity transform.
*
* @return unity transform
*/
public static Transform unity() {
return new Transform();
}
/**
* Constructor.
*
* @param m matrix
*/
private Transform(Matrix4d m) {
this.m = m;
}
/**
* Applies rotation operation around the x axis to this transform.
*
* @param degrees degrees
* @return this transform
*/
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
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies rotation operation around the y axis to this transform.
*
* @param degrees degrees
*
* @return this transform
*/
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
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies rotation operation around the z axis to this transform.
*
* @param degrees degrees
*
* @return this transform
*/
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
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a rotation operation to this transform.
*
* @param x x axis rotation (degrees)
* @param y y axis rotation (degrees)
* @param z z axis rotation (degrees)
*
* @return this transform
*/
public Transform rot(double x, double y, double z) {
return rotX(x).rotY(y).rotZ(z);
}
/**
* Applies a rotation operation to this transform.
*
* @param vec axis rotation for x, y, z (degrees)
*
* @return this transform
*/
public Transform rot(Vector3d vec) {
// TODO: use quaternions
return rotX(vec.x).rotY(vec.y).rotZ(vec.z);
}
/**
* Applies a translation operation to this transform.
*
* @param vec translation vector (x,y,z)
*
* @return this transform
*/
public Transform translate(Vector3d vec) {
return translate(vec.x, vec.y, vec.z);
}
/**
* Applies a translation operation to this transform.
*
* @param x translation (x axis)
* @param y translation (y axis)
* @param z translation (z axis)
*
* @return this transform
*/
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
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a translation operation to this transform.
*
* @param value translation (x axis)
*
* @return this transform
*/
public Transform translateX(double value) {
double elemenents[] = {
1, 0, 0, value,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a translation operation to this transform.
*
* @param value translation (y axis)
*
* @return this transform
*/
public Transform translateY(double value) {
double elemenents[] = {
1, 0, 0, 0,
0, 1, 0, value,
0, 0, 1, 0,
0, 0, 0, 1
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a translation operation to this transform.
*
* @param value translation (z axis)
*
* @return this transform
*/
public Transform translateZ(double value) {
double elemenents[] = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, value,
0, 0, 0, 1
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a mirror operation to this transform.
*
* @param plane the plane that defines the mirror operation
*
* @return this transform
*/
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
};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a scale operation to this transform.
*
* @param vec vector that specifies scale (x,y,z)
*
* @return this transform
*/
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};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a scale operation to this transform.
*
* @param x x scale value
* @param y y scale value
* @param z z scale value
*
* @return this transform
*/
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};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a scale operation to this transform.
*
* @param s s scale value (x, y and z)
*
* @return this transform
*/
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};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a scale operation (x axis) to this transform.
*
* @param s x scale value
*
* @return this transform
*/
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};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a scale operation (y axis) to this transform.
*
* @param s y scale value
*
* @return this transform
*/
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};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies a scale operation (z axis) to this transform.
*
* @param s z scale value
*
* @return this transform
*/
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};
m.mul(new Matrix4d(elemenents));
return this;
}
/**
* Applies this transform to the specified vector.
*
* @param vec vector to transform
*
* @return the specified vector
*/
public Vector3d transform(Vector3d vec) {
double x, y;
x = m.m00 * vec.x + m.m01 * vec.y + m.m02 * vec.z + m.m03;
y = m.m10 * vec.x + m.m11 * vec.y + m.m12 * vec.z + m.m13;
vec.z = m.m20 * vec.x + m.m21 * vec.y + m.m22 * vec.z + m.m23;
vec.x = x;
vec.y = y;
return vec;
}
/**
* Applies this transform to the specified vector.
*
* @param vec vector to transform
* @param amount transform amount (0 = 0 %, 1 = 100%)
*
* @return the specified vector
*/
public Vector3d transform(Vector3d vec, double amount) {
double prevX = vec.x;
double prevY = vec.y;
double prevZ = vec.z;
final double x, y;
x = m.m00 * vec.x + m.m01 * vec.y + m.m02 * vec.z + m.m03;
y = m.m10 * vec.x + m.m11 * vec.y + m.m12 * vec.z + m.m13;
vec.z = m.m20 * vec.x + m.m21 * vec.y + m.m22 * vec.z + m.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);
// },
/**
* Performs an SVD normalization of the underlying matrix to calculate and
* return the uniform scale factor. If the matrix has non-uniform scale
* factors, the largest of the x, y, and z scale factors distill be
* returned.
*
* Note: this transformation is not modified.
*
* @return the scale factor of this transformation
*/
public double getScale() {
return m.getScale();
}
/**
* Indicates whether this transform performs a mirror operation, i.e.,
* flips the orientation.
*
* @return true if this transform performs a mirror operation;
* false otherwise
*/
public boolean isMirror() {
return m.determinant() < 0;
}
/**
* Applies the specified transform to this transform.
*
* @param t transform to apply
*
* @return this transform
*/
public Transform apply(Transform t) {
m.mul(t.m);
return this;
}
@Override
public String toString() {
return m.toString();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy