To
build the vecmath package, you must first checkout the vecmath
CVS
repository on java.net. For example, run
the cvs checkout command as follows:
cd <cvs-root-dir>cvs checkout vecmath
This top-level directory must be named "vecmath".
Vecmath is 100% Java, so any operating environment that supports
J2SE should work. We have built vecmath on the following
operating environments:
The following software must be installed:
Before you start building, please check that your PATH must include the following directories:
The default target, jar-opt, creates an optimized jar files.
Steps:
cd <cvs-root-dir>/vecmath
ant
This will build the javax.vecmath package, which will
be put
in the vecmath/build/opt sub-directory.
To see other targets that are available, type "ant -projecthelp". Note that ant must be run from the top-level directory.
source-cvs/vecmath/LICENSE-SPEC.html 0000644 0001750 0001750 00000001603 10761613451 016356 0 ustar jonny jonnyCopyright 1996-2008 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms.
This javadoc-generated API documentation is not an official API specification. This documentation may contain references to Java and Java 3D, both of which are trademarks of Sun Microsystems, Inc. Any reference to these and other trademarks of Sun Microsystems are for explanatory purposes only. Their use does impart any rights beyond those listed in the source code license. In particular, Sun Microsystems retains all intellectual property and trademark rights as described in the proprietary rights notice in the COPYRIGHT.txt file.
source-cvs/vecmath/build.xml 0000644 0001750 0001750 00000021035 10761613451 015500 0 ustar jonny jonny* Note that Java defines a byte as a signed integer in the range * [-128, 127]. However, colors are more typically represented by values * in the range [0, 255]. Java 3D recognizes this and for color * treats the bytes as if the range were [0, 255]---in other words, as * if the bytes were unsigned. *
* Java 3D assumes that a linear (gamma-corrected) visual is used for
* all colors.
*
*/
public class Color4b extends Tuple4b implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = -105080578052502155L;
/**
* Constructs and initializes a Color4b from the four specified values.
* @param b1 the red color value
* @param b2 the green color value
* @param b3 the blue color value
* @param b4 the alpha value
*/
public Color4b(byte b1, byte b2, byte b3, byte b4) {
super(b1,b2,b3,b4);
}
/**
* Constructs and initializes a Color4b from the array of length 4.
* @param c the array of length 4 containing r, g, b, and alpha in order
*/
public Color4b(byte[] c) {
super(c);
}
/**
* Constructs and initializes a Color4b from the specified Color4b.
* @param c1 the Color4b containing the initialization r,g,b,a
* data
*/
public Color4b(Color4b c1) {
super(c1);
}
/**
* Constructs and initializes a Color4b from the specified Tuple4b.
* @param t1 the Tuple4b containing the initialization r,g,b,a
* data
*/
public Color4b(Tuple4b t1) {
super(t1);
}
/**
* Constructs and initializes a Color4b from the specified AWT
* Color object.
* No conversion is done on the color to compensate for
* gamma correction.
*
* @param color the AWT color with which to initialize this
* Color4b object
*
* @since vecmath 1.2
*/
public Color4b(Color color) {
super((byte)color.getRed(),
(byte)color.getGreen(),
(byte)color.getBlue(),
(byte)color.getAlpha());
}
/**
* Constructs and initializes a Color4b to (0,0,0,0).
*/
public Color4b() {
super();
}
/**
* Sets the r,g,b,a values of this Color4b object to those of the
* specified AWT Color object.
* No conversion is done on the color to compensate for
* gamma correction.
*
* @param color the AWT color to copy into this Color4b object
*
* @since vecmath 1.2
*/
public final void set(Color color) {
x = (byte)color.getRed();
y = (byte)color.getGreen();
z = (byte)color.getBlue();
w = (byte)color.getAlpha();
}
/**
* Returns a new AWT color object initialized with the r,g,b,a
* values of this Color4b object.
*
* @return a new AWT Color object
*
* @since vecmath 1.2
*/
public final Color get() {
int r = (int)x & 0xff;
int g = (int)y & 0xff;
int b = (int)z & 0xff;
int a = (int)w & 0xff;
return new Color(r, g, b, a);
}
}
source-cvs/vecmath/src/javax/vecmath/Tuple3i.java 0000644 0001750 0001750 00000031351 10761613453 021402 0 ustar jonny jonny /*
* $RCSfile: Tuple3i.java,v $
*
* Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.7 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 3-element tuple represented by signed integer x,y,z
* coordinates.
*
* @since vecmath 1.2
*/
public abstract class Tuple3i implements java.io.Serializable, Cloneable {
static final long serialVersionUID = -732740491767276200L;
/**
* The x coordinate.
*/
public int x;
/**
* The y coordinate.
*/
public int y;
/**
* The z coordinate.
*/
public int z;
/**
* Constructs and initializes a Tuple3i from the specified
* x, y, and z coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public Tuple3i(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Constructs and initializes a Tuple3i from the array of length 3.
* @param t the array of length 3 containing x, y, and z in order.
*/
public Tuple3i(int[] t) {
this.x = t[0];
this.y = t[1];
this.z = t[2];
}
/**
* Constructs and initializes a Tuple3i from the specified Tuple3i.
* @param t1 the Tuple3i containing the initialization x, y, and z
* data.
*/
public Tuple3i(Tuple3i t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
}
/**
* Constructs and initializes a Tuple3i to (0,0,0).
*/
public Tuple3i() {
this.x = 0;
this.y = 0;
this.z = 0;
}
/**
* Sets the value of this tuple to the specified x, y, and z
* coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public final void set(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Sets the value of this tuple to the specified coordinates in the
* array of length 3.
* @param t the array of length 3 containing x, y, and z in order.
*/
public final void set(int[] t) {
this.x = t[0];
this.y = t[1];
this.z = t[2];
}
/**
* Sets the value of this tuple to the value of tuple t1.
* @param t1 the tuple to be copied
*/
public final void set(Tuple3i t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
}
/**
* Copies the values of this tuple into the array t.
* @param t is the array
*/
public final void get(int[] t) {
t[0] = this.x;
t[1] = this.y;
t[2] = this.z;
}
/**
* Copies the values of this tuple into the tuple t.
* @param t is the target tuple
*/
public final void get(Tuple3i t) {
t.x = this.x;
t.y = this.y;
t.z = this.z;
}
/**
* Sets the value of this tuple to the sum of tuples t1 and t2.
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void add(Tuple3i t1, Tuple3i t2) {
this.x = t1.x + t2.x;
this.y = t1.y + t2.y;
this.z = t1.z + t2.z;
}
/**
* Sets the value of this tuple to the sum of itself and t1.
* @param t1 the other tuple
*/
public final void add(Tuple3i t1) {
this.x += t1.x;
this.y += t1.y;
this.z += t1.z;
}
/**
* Sets the value of this tuple to the difference
* of tuples t1 and t2 (this = t1 - t2).
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void sub(Tuple3i t1, Tuple3i t2) {
this.x = t1.x - t2.x;
this.y = t1.y - t2.y;
this.z = t1.z - t2.z;
}
/**
* Sets the value of this tuple to the difference
* of itself and t1 (this = this - t1).
* @param t1 the other tuple
*/
public final void sub(Tuple3i t1) {
this.x -= t1.x;
this.y -= t1.y;
this.z -= t1.z;
}
/**
* Sets the value of this tuple to the negation of tuple t1.
* @param t1 the source tuple
*/
public final void negate(Tuple3i t1) {
this.x = -t1.x;
this.y = -t1.y;
this.z = -t1.z;
}
/**
* Negates the value of this tuple in place.
*/
public final void negate() {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1.
* @param s the scalar value
* @param t1 the source tuple
*/
public final void scale(int s, Tuple3i t1) {
this.x = s*t1.x;
this.y = s*t1.y;
this.z = s*t1.z;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of the scale factor with this.
* @param s the scalar value
*/
public final void scale(int s) {
this.x *= s;
this.y *= s;
this.z *= s;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1 plus tuple t2 (this = s*t1 + t2).
* @param s the scalar value
* @param t1 the tuple to be multipled
* @param t2 the tuple to be added
*/
public final void scaleAdd(int s, Tuple3i t1, Tuple3i t2) {
this.x = s*t1.x + t2.x;
this.y = s*t1.y + t2.y;
this.z = s*t1.z + t2.z;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself and then adds tuple t1 (this = s*this + t1).
* @param s the scalar value
* @param t1 the tuple to be added
*/
public final void scaleAdd(int s, Tuple3i t1) {
this.x = s*this.x + t1.x;
this.y = s*this.y + t1.y;
this.z = s*this.z + t1.z;
}
/**
* Returns a string that contains the values of this Tuple3i.
* The form is (x,y,z).
* @return the String representation
*/
public String toString() {
return "(" + this.x + ", " + this.y + ", " + this.z + ")";
}
/**
* Returns true if the Object t1 is of type Tuple3i and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple3i.
* @param t1 the object with which the comparison is made
*/
public boolean equals(Object t1) {
try {
Tuple3i t2 = (Tuple3i) t1;
return(this.x == t2.x && this.y == t2.y && this.z == t2.z);
}
catch (NullPointerException e2) {
return false;
}
catch (ClassCastException e1) {
return false;
}
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple3i objects with identical data values
* (i.e., Tuple3i.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + (long)x;
bits = 31L * bits + (long)y;
bits = 31L * bits + (long)z;
return (int) (bits ^ (bits >> 32));
}
/**
* Clamps the tuple parameter to the range [low, high] and
* places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clamp(int min, int max, Tuple3i t) {
if( t.x > max ) {
x = max;
} else if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else if( t.y < min ) {
y = min;
} else {
y = t.y;
}
if( t.z > max ) {
z = max;
} else if( t.z < min ) {
z = min;
} else {
z = t.z;
}
}
/**
* Clamps the minimum value of the tuple parameter to the min
* parameter and places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMin(int min, Tuple3i t) {
if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y < min ) {
y = min;
} else {
y = t.y;
}
if( t.z < min ) {
z = min;
} else {
z = t.z;
}
}
/**
* Clamps the maximum value of the tuple parameter to the max
* parameter and places the values into this tuple.
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMax(int max, Tuple3i t) {
if( t.x > max ) {
x = max;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else {
y = t.y;
}
if( t.z > max ) {
z = max;
} else {
z = t.z;
}
}
/**
* Sets each component of the tuple parameter to its absolute
* value and places the modified values into this tuple.
* @param t the source tuple, which will not be modified
*/
public final void absolute(Tuple3i t) {
x = Math.abs(t.x);
y = Math.abs(t.y);
z = Math.abs(t.z);
}
/**
* Clamps this tuple to the range [low, high].
* @param min the lowest value in this tuple after clamping
* @param max the highest value in this tuple after clamping
*/
public final void clamp(int min, int max) {
if( x > max ) {
x = max;
} else if( x < min ) {
x = min;
}
if( y > max ) {
y = max;
} else if( y < min ) {
y = min;
}
if( z > max ) {
z = max;
} else if( z < min ) {
z = min;
}
}
/**
* Clamps the minimum value of this tuple to the min parameter.
* @param min the lowest value in this tuple after clamping
*/
public final void clampMin(int min) {
if (x < min)
x=min;
if (y < min)
y = min;
if (z < min)
z = min;
}
/**
* Clamps the maximum value of this tuple to the max parameter.
* @param max the highest value in the tuple after clamping
*/
public final void clampMax(int max) {
if (x > max)
x = max;
if (y > max)
y = max;
if (z > max)
z = max;
}
/**
* Sets each component of this tuple to its absolute value.
*/
public final void absolute() {
x = Math.abs(x);
y = Math.abs(y);
z = Math.abs(z);
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public final int getX() {
return x;
}
/**
* Set the x coordinate.
*
* @param x value to x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(int x) {
this.x = x;
}
/**
* Get the y coordinate.
*
* @return the y coordinate.
*
* @since vecmath 1.5
*/
public final int getY() {
return y;
}
/**
* Set the y coordinate.
*
* @param y value to y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(int y) {
this.y = y;
}
/**
* Get the z coordinate.
*
* @return the z coordinate.
* @since vecmath 1.5
*/
public final int getZ() {
return z;
}
/**
* Set the z coordinate.
*
* @param z value to z coordinate.
*
* @since vecmath 1.5
*/
public final void setZ(int z) {
this.z = z;
}
}
source-cvs/vecmath/src/javax/vecmath/Tuple2i.java 0000644 0001750 0001750 00000026550 10761613453 021406 0 ustar jonny jonny /*
* $RCSfile: Tuple2i.java,v $
*
* Copyright 2005-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.6 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 2-element tuple represented by signed integer x,y
* coordinates.
*
* @since vecmath 1.4
*/
public abstract class Tuple2i implements java.io.Serializable, Cloneable {
static final long serialVersionUID = -3555701650170169638L;
/**
* The x coordinate.
*/
public int x;
/**
* The y coordinate.
*/
public int y;
/**
* Constructs and initializes a Tuple2i from the specified
* x and y coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public Tuple2i(int x, int y) {
this.x = x;
this.y = y;
}
/**
* Constructs and initializes a Tuple2i from the array of length 2.
* @param t the array of length 2 containing x and y in order.
*/
public Tuple2i(int[] t) {
this.x = t[0];
this.y = t[1];
}
/**
* Constructs and initializes a Tuple2i from the specified Tuple2i.
* @param t1 the Tuple2i containing the initialization x and y
* data.
*/
public Tuple2i(Tuple2i t1) {
this.x = t1.x;
this.y = t1.y;
}
/**
* Constructs and initializes a Tuple2i to (0,0).
*/
public Tuple2i() {
this.x = 0;
this.y = 0;
}
/**
* Sets the value of this tuple to the specified x and y
* coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public final void set(int x, int y) {
this.x = x;
this.y = y;
}
/**
* Sets the value of this tuple to the specified coordinates in the
* array of length 2.
* @param t the array of length 2 containing x and y in order.
*/
public final void set(int[] t) {
this.x = t[0];
this.y = t[1];
}
/**
* Sets the value of this tuple to the value of tuple t1.
* @param t1 the tuple to be copied
*/
public final void set(Tuple2i t1) {
this.x = t1.x;
this.y = t1.y;
}
/**
* Copies the values of this tuple into the array t.
* @param t is the array
*/
public final void get(int[] t) {
t[0] = this.x;
t[1] = this.y;
}
/**
* Copies the values of this tuple into the tuple t.
* @param t is the target tuple
*/
public final void get(Tuple2i t) {
t.x = this.x;
t.y = this.y;
}
/**
* Sets the value of this tuple to the sum of tuples t1 and t2.
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void add(Tuple2i t1, Tuple2i t2) {
this.x = t1.x + t2.x;
this.y = t1.y + t2.y;
}
/**
* Sets the value of this tuple to the sum of itself and t1.
* @param t1 the other tuple
*/
public final void add(Tuple2i t1) {
this.x += t1.x;
this.y += t1.y;
}
/**
* Sets the value of this tuple to the difference
* of tuples t1 and t2 (this = t1 - t2).
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void sub(Tuple2i t1, Tuple2i t2) {
this.x = t1.x - t2.x;
this.y = t1.y - t2.y;
}
/**
* Sets the value of this tuple to the difference
* of itself and t1 (this = this - t1).
* @param t1 the other tuple
*/
public final void sub(Tuple2i t1) {
this.x -= t1.x;
this.y -= t1.y;
}
/**
* Sets the value of this tuple to the negation of tuple t1.
* @param t1 the source tuple
*/
public final void negate(Tuple2i t1) {
this.x = -t1.x;
this.y = -t1.y;
}
/**
* Negates the value of this tuple in place.
*/
public final void negate() {
this.x = -this.x;
this.y = -this.y;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1.
* @param s the scalar value
* @param t1 the source tuple
*/
public final void scale(int s, Tuple2i t1) {
this.x = s*t1.x;
this.y = s*t1.y;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of the scale factor with this.
* @param s the scalar value
*/
public final void scale(int s) {
this.x *= s;
this.y *= s;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1 plus tuple t2 (this = s*t1 + t2).
* @param s the scalar value
* @param t1 the tuple to be multipled
* @param t2 the tuple to be added
*/
public final void scaleAdd(int s, Tuple2i t1, Tuple2i t2) {
this.x = s*t1.x + t2.x;
this.y = s*t1.y + t2.y;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself and then adds tuple t1 (this = s*this + t1).
* @param s the scalar value
* @param t1 the tuple to be added
*/
public final void scaleAdd(int s, Tuple2i t1) {
this.x = s*this.x + t1.x;
this.y = s*this.y + t1.y;
}
/**
* Returns a string that contains the values of this Tuple2i.
* The form is (x,y).
* @return the String representation
*/
public String toString() {
return "(" + this.x + ", " + this.y + ")";
}
/**
* Returns true if the Object t1 is of type Tuple2i and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple2i.
* @param t1 the object with which the comparison is made
*/
public boolean equals(Object t1) {
try {
Tuple2i t2 = (Tuple2i) t1;
return(this.x == t2.x && this.y == t2.y);
}
catch (NullPointerException e2) {
return false;
}
catch (ClassCastException e1) {
return false;
}
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple2i objects with identical data values
* (i.e., Tuple2i.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + (long)x;
bits = 31L * bits + (long)y;
return (int) (bits ^ (bits >> 32));
}
/**
* Clamps the tuple parameter to the range [low, high] and
* places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clamp(int min, int max, Tuple2i t) {
if( t.x > max ) {
x = max;
} else if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else if( t.y < min ) {
y = min;
} else {
y = t.y;
}
}
/**
* Clamps the minimum value of the tuple parameter to the min
* parameter and places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMin(int min, Tuple2i t) {
if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y < min ) {
y = min;
} else {
y = t.y;
}
}
/**
* Clamps the maximum value of the tuple parameter to the max
* parameter and places the values into this tuple.
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMax(int max, Tuple2i t) {
if( t.x > max ) {
x = max;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else {
y = t.y;
}
}
/**
* Sets each component of the tuple parameter to its absolute
* value and places the modified values into this tuple.
* @param t the source tuple, which will not be modified
*/
public final void absolute(Tuple2i t) {
x = Math.abs(t.x);
y = Math.abs(t.y);
}
/**
* Clamps this tuple to the range [low, high].
* @param min the lowest value in this tuple after clamping
* @param max the highest value in this tuple after clamping
*/
public final void clamp(int min, int max) {
if( x > max ) {
x = max;
} else if( x < min ) {
x = min;
}
if( y > max ) {
y = max;
} else if( y < min ) {
y = min;
}
}
/**
* Clamps the minimum value of this tuple to the min parameter.
* @param min the lowest value in this tuple after clamping
*/
public final void clampMin(int min) {
if (x < min)
x=min;
if (y < min)
y = min;
}
/**
* Clamps the maximum value of this tuple to the max parameter.
* @param max the highest value in the tuple after clamping
*/
public final void clampMax(int max) {
if (x > max)
x = max;
if (y > max)
y = max;
}
/**
* Sets each component of this tuple to its absolute value.
*/
public final void absolute() {
x = Math.abs(x);
y = Math.abs(y);
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public final int getX() {
return x;
}
/**
* Set the x coordinate.
*
* @param x value to x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(int x) {
this.x = x;
}
/**
* Get the y coordinate.
*
* @return the y coordinate.
*
* @since vecmath 1.5
*/
public final int getY() {
return y;
}
/**
* Set the y coordinate.
*
* @param y value to y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(int y) {
this.y = y;
}
}
source-cvs/vecmath/src/javax/vecmath/TexCoord2f.java 0000644 0001750 0001750 00000005174 10761613452 022037 0 ustar jonny jonny /*
* $RCSfile: TexCoord2f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 2-element vector that is represented by single-precision floating
* point x,y coordinates.
*
*/
public class TexCoord2f extends Tuple2f implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = 7998248474800032487L;
/**
* Constructs and initializes a TexCoord2f from the specified xy coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public TexCoord2f(float x, float y)
{
super(x,y);
}
/**
* Constructs and initializes a TexCoord2f from the specified array.
* @param v the array of length 2 containing xy in order
*/
public TexCoord2f(float[] v)
{
super(v);
}
/**
* Constructs and initializes a TexCoord2f from the specified TexCoord2f.
* @param v1 the TexCoord2f containing the initialization x y data
*/
public TexCoord2f(TexCoord2f v1)
{
super(v1);
}
/**
* Constructs and initializes a TexCoord2f from the specified Tuple2f.
* @param t1 the Tuple2f containing the initialization x y data
*/
public TexCoord2f(Tuple2f t1)
{
super(t1);
}
/**
* Constructs and initializes a TexCoord2f to (0,0).
*/
public TexCoord2f()
{
super();
}
}
source-cvs/vecmath/src/javax/vecmath/GMatrix.java 0000644 0001750 0001750 00000214400 10761613452 021425 0 ustar jonny jonny /*
* $RCSfile: GMatrix.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.7 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A double precision, general, dynamically-resizable,
* two-dimensional matrix class. Row and column numbering begins with
* zero. The representation is row major.
*/
public class GMatrix implements java.io.Serializable, Cloneable {
// Compatible with 1.1
static final long serialVersionUID = 2777097312029690941L;
private static final boolean debug = false;
int nRow;
int nCol;
// double dereference is slow
double[][] values;
private static final double EPS = 1.0E-10;
/**
* Constructs an nRow by NCol identity matrix.
* Note that because row and column numbering begins with
* zero, nRow and nCol will be one larger than the maximum
* possible matrix index values.
* @param nRow number of rows in this matrix.
* @param nCol number of columns in this matrix.
*/
public GMatrix(int nRow, int nCol)
{
values = new double[nRow][nCol];
this.nRow = nRow;
this.nCol = nCol;
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = 0.0;
}
}
int l;
if (nRow < nCol)
l = nRow;
else
l = nCol;
for (i = 0; i < l; i++) {
values[i][i] = 1.0;
}
}
/**
* Constructs an nRow by nCol matrix initialized to the values
* in the matrix array. The array values are copied in one row at
* a time in row major fashion. The array should be at least
* nRow*nCol in length.
* Note that because row and column numbering begins with
* zero, nRow and nCol will be one larger than the maximum
* possible matrix index values.
* @param nRow number of rows in this matrix.
* @param nCol number of columns in this matrix.
* @param matrix a 1D array that specifies a matrix in row major fashion
*/
public GMatrix(int nRow, int nCol, double[] matrix)
{
values = new double[nRow][nCol];
this.nRow = nRow;
this.nCol = nCol;
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = matrix[i*nCol+j];
}
}
}
/**
* Constructs a new GMatrix and copies the initial values
* from the parameter matrix.
* @param matrix the source of the initial values of the new GMatrix
*/
public GMatrix(GMatrix matrix)
{
nRow = matrix.nRow;
nCol = matrix.nCol;
values = new double[nRow][nCol];
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = matrix.values[i][j];
}
}
}
/**
* Sets the value of this matrix to the result of multiplying itself
* with matrix m1 (this = this * m1).
* @param m1 the other matrix
*/
public final void mul(GMatrix m1)
{
int i, j, k;
if (nCol != m1.nRow || nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix0"));
double [][] tmp = new double[nRow][nCol];
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
tmp[i][j] = 0.0;
for (k = 0; k < nCol; k++) {
tmp[i][j] += values[i][k]*m1.values[k][j];
}
}
}
values = tmp;
}
/**
* Sets the value of this matrix to the result of multiplying
* the two argument matrices together (this = m1 * m2).
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void mul(GMatrix m1, GMatrix m2)
{
int i, j, k;
if (m1.nCol != m2.nRow || nRow != m1.nRow || nCol != m2.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix1"));
double[][] tmp = new double[nRow][nCol];
for (i = 0; i < m1.nRow; i++) {
for (j = 0; j < m2.nCol; j++) {
tmp[i][j] = 0.0;
for (k = 0; k < m1.nCol; k++) {
tmp[i][j] += m1.values[i][k]*m2.values[k][j];
}
}
}
values = tmp;
}
/**
* Computes the outer product of the two vectors; multiplies the
* the first vector by the transpose of the second vector and places
* the matrix result into this matrix. This matrix must be
* be as big or bigger than getSize(v1)xgetSize(v2).
* @param v1 the first vector, treated as a row vector
* @param v2 the second vector, treated as a column vector
*/
public final void mul(GVector v1, GVector v2)
{
int i, j;
if (nRow < v1.getSize())
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix2"));
if (nCol < v2.getSize())
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix3"));
for (i = 0; i < v1.getSize(); i++ ) {
for (j = 0; j < v2.getSize(); j++ ) {
values[i][j] = v1.values[i]*v2.values[j];
}
}
}
/**
* Sets the value of this matrix to sum of itself and matrix m1.
* @param m1 the other matrix
*/
public final void add(GMatrix m1)
{
int i, j;
if (nRow != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix4"));
if (nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix5"));
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = values[i][j] + m1.values[i][j];
}
}
}
/**
* Sets the value of this matrix to the matrix sum of matrices m1 and m2.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void add(GMatrix m1, GMatrix m2)
{
int i, j;
if (m2.nRow != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix6"));
if (m2.nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix7"));
if (nCol != m1.nCol || nRow != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix8"));
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = m1.values[i][j] + m2.values[i][j];
}
}
}
/**
* Sets the value of this matrix to the matrix difference of itself
* and matrix m1 (this = this - m1).
* @param m1 the other matrix
*/
public final void sub(GMatrix m1)
{
int i, j;
if (nRow != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix9"));
if (nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix28"));
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = values[i][j] - m1.values[i][j];
}
}
}
/**
* Sets the value of this matrix to the matrix difference
* of matrices m1 and m2 (this = m1 - m2).
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void sub(GMatrix m1, GMatrix m2)
{
int i, j;
if (m2.nRow != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix10"));
if (m2.nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix11"));
if (nRow != m1.nRow || nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix12"));
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = m1.values[i][j] - m2.values[i][j];
}
}
}
/**
* Negates the value of this matrix: this = -this.
*/
public final void negate()
{
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0;j < nCol; j++) {
values[i][j] = -values[i][j];
}
}
}
/**
* Sets the value of this matrix equal to the negation of
* of the GMatrix parameter.
* @param m1 The source matrix
*/
public final void negate(GMatrix m1)
{
int i, j;
if (nRow != m1.nRow || nCol != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix13"));
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = -m1.values[i][j];
}
}
}
/**
* Sets this GMatrix to the identity matrix.
*/
public final void setIdentity()
{
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = 0.0;
}
}
int l;
if (nRow < nCol)
l = nRow;
else
l = nCol;
for (i = 0; i < l; i++) {
values[i][i] = 1.0;
}
}
/**
* Sets all the values in this matrix to zero.
*/
public final void setZero()
{
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = 0.0;
}
}
}
/**
* Subtracts this matrix from the identity matrix and puts the values
* back into this (this = I - this).
*/
public final void identityMinus()
{
int i, j;
for(i = 0; i < nRow; i++) {
for(j = 0; j < nCol; j++) {
values[i][j] = -values[i][j];
}
}
int l;
if( nRow < nCol)
l = nRow;
else
l = nCol;
for(i = 0; i < l; i++) {
values[i][i] += 1.0;
}
}
/**
* Inverts this matrix in place.
*/
public final void invert()
{
invertGeneral(this);
}
/**
* Inverts matrix m1 and places the new values into this matrix. Matrix
* m1 is not modified.
* @param m1 the matrix to be inverted
*/
public final void invert(GMatrix m1)
{
invertGeneral(m1);
}
/**
* Copies a sub-matrix derived from this matrix into the target matrix.
* The upper left of the sub-matrix is located at (rowSource, colSource);
* the lower right of the sub-matrix is located at
* (lastRowSource,lastColSource). The sub-matrix is copied into the
* the target matrix starting at (rowDest, colDest).
* @param rowSource the top-most row of the sub-matrix
* @param colSource the left-most column of the sub-matrix
* @param numRow the number of rows in the sub-matrix
* @param numCol the number of columns in the sub-matrix
* @param rowDest the top-most row of the position of the copied
* sub-matrix within the target matrix
* @param colDest the left-most column of the position of the copied
* sub-matrix within the target matrix
* @param target the matrix into which the sub-matrix will be copied
*/
public final void copySubMatrix(int rowSource, int colSource,
int numRow, int numCol, int rowDest,
int colDest, GMatrix target)
{
int i, j;
if (this != target) {
for (i = 0; i < numRow; i++) {
for (j = 0; j < numCol; j++) {
target.values[rowDest+i][colDest+j] =
values[rowSource+i][colSource+j];
}
}
} else {
double[][] tmp = new double[numRow][numCol];
for (i = 0; i < numRow; i++) {
for (j = 0; j < numCol; j++) {
tmp[i][j] = values[rowSource+i][colSource+j];
}
}
for (i = 0; i < numRow; i++) {
for (j = 0; j < numCol; j++) {
target.values[rowDest+i][colDest+j] = tmp[i][j];
}
}
}
}
/**
* Changes the size of this matrix dynamically. If the size is increased
* no data values will be lost. If the size is decreased, only those data
* values whose matrix positions were eliminated will be lost.
* @param nRow number of desired rows in this matrix
* @param nCol number of desired columns in this matrix
*/
public final void setSize(int nRow, int nCol)
{
double[][] tmp = new double[nRow][nCol];
int i, j, maxRow, maxCol;
if (this.nRow < nRow)
maxRow = this.nRow;
else
maxRow = nRow;
if (this.nCol < nCol)
maxCol = this.nCol;
else
maxCol = nCol;
for (i = 0; i < maxRow; i++) {
for (j = 0; j < maxCol; j++) {
tmp[i][j] = values[i][j];
}
}
this.nRow = nRow;
this.nCol = nCol;
values = tmp;
}
/**
* Sets the value of this matrix to the values found in the array parameter.
* The values are copied in one row at a time, in row major
* fashion. The array should be at least equal in length to
* the number of matrix rows times the number of matrix columns
* in this matrix.
* @param matrix the row major source array
*/
public final void set(double[] matrix)
{
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = matrix[nCol*i+j];
}
}
}
/**
* Sets the value of this matrix to that of the Matrix3f provided.
* @param m1 the matrix
*/
public final void set(Matrix3f m1)
{
int i, j;
if (nCol < 3 || nRow < 3) { // expand matrix if too small
nCol = 3;
nRow = 3;
values = new double[nRow][nCol];
}
values[0][0] = m1.m00;
values[0][1] = m1.m01;
values[0][2] = m1.m02;
values[1][0] = m1.m10;
values[1][1] = m1.m11;
values[1][2] = m1.m12;
values[2][0] = m1.m20;
values[2][1] = m1.m21;
values[2][2] = m1.m22;
for (i = 3; i < nRow; i++) { // pad rest or matrix with zeros
for (j = 3; j < nCol; j++) {
values[i][j] = 0.0;
}
}
}
/**
* Sets the value of this matrix to that of the Matrix3d provided.
* @param m1 the matrix
*/
public final void set(Matrix3d m1)
{
if (nRow < 3 || nCol < 3) {
values = new double[3][3];
nRow = 3;
nCol = 3;
}
values[0][0] = m1.m00;
values[0][1] = m1.m01;
values[0][2] = m1.m02;
values[1][0] = m1.m10;
values[1][1] = m1.m11;
values[1][2] = m1.m12;
values[2][0] = m1.m20;
values[2][1] = m1.m21;
values[2][2] = m1.m22;
for (int i = 3; i < nRow; i++) { // pad rest or matrix with zeros
for(int j = 3; j < nCol; j++) {
values[i][j] = 0.0;
}
}
}
/**
* Sets the value of this matrix to that of the Matrix4f provided.
* @param m1 the matrix
*/
public final void set(Matrix4f m1)
{
if (nRow < 4 || nCol < 4) {
values = new double[4][4];
nRow = 4;
nCol = 4;
}
values[0][0] = m1.m00;
values[0][1] = m1.m01;
values[0][2] = m1.m02;
values[0][3] = m1.m03;
values[1][0] = m1.m10;
values[1][1] = m1.m11;
values[1][2] = m1.m12;
values[1][3] = m1.m13;
values[2][0] = m1.m20;
values[2][1] = m1.m21;
values[2][2] = m1.m22;
values[2][3] = m1.m23;
values[3][0] = m1.m30;
values[3][1] = m1.m31;
values[3][2] = m1.m32;
values[3][3] = m1.m33;
for (int i = 4 ; i < nRow; i++) { // pad rest or matrix with zeros
for (int j = 4; j < nCol; j++) {
values[i][j] = 0.0;
}
}
}
/**
* Sets the value of this matrix to that of the Matrix4d provided.
* @param m1 the matrix
*/
public final void set(Matrix4d m1)
{
if (nRow < 4 || nCol < 4) {
values = new double[4][4];
nRow = 4;
nCol = 4;
}
values[0][0] = m1.m00;
values[0][1] = m1.m01;
values[0][2] = m1.m02;
values[0][3] = m1.m03;
values[1][0] = m1.m10;
values[1][1] = m1.m11;
values[1][2] = m1.m12;
values[1][3] = m1.m13;
values[2][0] = m1.m20;
values[2][1] = m1.m21;
values[2][2] = m1.m22;
values[2][3] = m1.m23;
values[3][0] = m1.m30;
values[3][1] = m1.m31;
values[3][2] = m1.m32;
values[3][3] = m1.m33;
for (int i = 4; i < nRow; i++) { // pad rest or matrix with zeros
for (int j = 4; j < nCol; j++) {
values[i][j] = 0.0;
}
}
}
/**
* Sets the value of this matrix to the values found in matrix m1.
* @param m1 the source matrix
*/
public final void set(GMatrix m1)
{
int i, j;
if (nRow < m1.nRow || nCol < m1.nCol) {
nRow = m1.nRow;
nCol = m1.nCol;
values = new double[nRow][nCol];
}
for (i = 0; i < Math.min(nRow, m1.nRow); i++) {
for (j = 0; j < Math.min(nCol, m1.nCol); j++) {
values[i][j] = m1.values[i][j];
}
}
for (i = m1.nRow; i < nRow; i++) { // pad rest or matrix with zeros
for (j = m1.nCol; j < nCol; j++) {
values[i][j] = 0.0;
}
}
}
/**
* Returns the number of rows in this matrix.
* @return number of rows in this matrix
*/
public final int getNumRow()
{
return(nRow);
}
/**
* Returns the number of colmuns in this matrix.
* @return number of columns in this matrix
*/
public final int getNumCol()
{
return(nCol);
}
/**
* Retrieves the value at the specified row and column of this matrix.
* @param row the row number to be retrieved (zero indexed)
* @param column the column number to be retrieved (zero indexed)
* @return the value at the indexed element
*/
public final double getElement(int row, int column)
{
return(values[row][column]);
}
/**
* Modifies the value at the specified row and column of this matrix.
* @param row the row number to be modified (zero indexed)
* @param column the column number to be modified (zero indexed)
* @param value the new matrix element value
*/
public final void setElement(int row, int column, double value)
{
values[row][column] = value;
}
/**
* Places the values of the specified row into the array parameter.
* @param row the target row number
* @param array the array into which the row values will be placed
*/
public final void getRow(int row, double[] array)
{
for (int i = 0; i < nCol; i++) {
array[i] = values[row][i];
}
}
/**
* Places the values of the specified row into the vector parameter.
* @param row the target row number
* @param vector the vector into which the row values will be placed
*/
public final void getRow(int row, GVector vector)
{
if (vector.getSize() < nCol)
vector.setSize(nCol);
for (int i = 0; i < nCol; i++) {
vector.values[i] = values[row][i];
}
}
/**
* Places the values of the specified column into the array parameter.
* @param col the target column number
* @param array the array into which the column values will be placed
*/
public final void getColumn(int col, double[] array)
{
for (int i = 0; i < nRow; i++) {
array[i] = values[i][col];
}
}
/**
* Places the values of the specified column into the vector parameter.
* @param col the target column number
* @param vector the vector into which the column values will be placed
*/
public final void getColumn(int col, GVector vector)
{
if (vector.getSize() < nRow)
vector.setSize(nRow);
for (int i = 0; i < nRow; i++) {
vector.values[i] = values[i][col];
}
}
/**
* Places the values in the upper 3x3 of this GMatrix into
* the matrix m1.
* @param m1 The matrix that will hold the new values
*/
public final void get(Matrix3d m1)
{
if (nRow < 3 || nCol < 3) {
m1.setZero();
if (nCol > 0) {
if (nRow > 0){
m1.m00 = values[0][0];
if (nRow > 1){
m1.m10 = values[1][0];
if( nRow > 2 ){
m1.m20= values[2][0];
}
}
}
if (nCol > 1) {
if (nRow > 0) {
m1.m01 = values[0][1];
if (nRow > 1){
m1.m11 = values[1][1];
if (nRow > 2){
m1.m21 = values[2][1];
}
}
}
if (nCol > 2) {
if (nRow > 0) {
m1.m02 = values[0][2];
if (nRow > 1) {
m1.m12 = values[1][2];
if (nRow > 2) {
m1.m22 = values[2][2];
}
}
}
}
}
}
} else {
m1.m00 = values[0][0];
m1.m01 = values[0][1];
m1.m02 = values[0][2];
m1.m10 = values[1][0];
m1.m11 = values[1][1];
m1.m12 = values[1][2];
m1.m20 = values[2][0];
m1.m21 = values[2][1];
m1.m22 = values[2][2];
}
}
/**
* Places the values in the upper 3x3 of this GMatrix into
* the matrix m1.
* @param m1 The matrix that will hold the new values
*/
public final void get(Matrix3f m1)
{
if (nRow < 3 || nCol < 3) {
m1.setZero();
if (nCol > 0) {
if (nRow > 0) {
m1.m00 = (float)values[0][0];
if (nRow > 1) {
m1.m10 = (float)values[1][0];
if (nRow > 2) {
m1.m20 = (float)values[2][0];
}
}
}
if (nCol > 1) {
if (nRow > 0) {
m1.m01 = (float)values[0][1];
if (nRow > 1){
m1.m11 = (float)values[1][1];
if (nRow > 2){
m1.m21 = (float)values[2][1];
}
}
}
if (nCol > 2) {
if (nRow > 0) {
m1.m02 = (float)values[0][2];
if (nRow > 1) {
m1.m12 = (float)values[1][2];
if (nRow > 2) {
m1.m22 = (float)values[2][2];
}
}
}
}
}
}
} else {
m1.m00 = (float)values[0][0];
m1.m01 = (float)values[0][1];
m1.m02 = (float)values[0][2];
m1.m10 = (float)values[1][0];
m1.m11 = (float)values[1][1];
m1.m12 = (float)values[1][2];
m1.m20 = (float)values[2][0];
m1.m21 = (float)values[2][1];
m1.m22 = (float)values[2][2];
}
}
/**
* Places the values in the upper 4x4 of this GMatrix into
* the matrix m1.
* @param m1 The matrix that will hold the new values
*/
public final void get(Matrix4d m1)
{
if (nRow < 4 || nCol < 4) {
m1.setZero();
if (nCol > 0) {
if (nRow > 0) {
m1.m00 = values[0][0];
if (nRow > 1) {
m1.m10 = values[1][0];
if (nRow > 2) {
m1.m20 = values[2][0];
if (nRow > 3) {
m1.m30 = values[3][0];
}
}
}
}
if (nCol > 1) {
if (nRow > 0) {
m1.m01 = values[0][1];
if (nRow > 1) {
m1.m11 = values[1][1];
if (nRow > 2) {
m1.m21 = values[2][1];
if (nRow > 3) {
m1.m31 = values[3][1];
}
}
}
}
if (nCol > 2) {
if (nRow > 0) {
m1.m02 = values[0][2];
if (nRow > 1) {
m1.m12 = values[1][2];
if (nRow > 2) {
m1.m22 = values[2][2];
if (nRow > 3) {
m1.m32 = values[3][2];
}
}
}
}
if (nCol > 3) {
if (nRow > 0) {
m1.m03 = values[0][3];
if (nRow > 1) {
m1.m13 = values[1][3];
if (nRow > 2) {
m1.m23 = values[2][3];
if (nRow > 3) {
m1.m33 = values[3][3];
}
}
}
}
}
}
}
}
} else {
m1.m00 = values[0][0];
m1.m01 = values[0][1];
m1.m02 = values[0][2];
m1.m03 = values[0][3];
m1.m10 = values[1][0];
m1.m11 = values[1][1];
m1.m12 = values[1][2];
m1.m13 = values[1][3];
m1.m20 = values[2][0];
m1.m21 = values[2][1];
m1.m22 = values[2][2];
m1.m23 = values[2][3];
m1.m30 = values[3][0];
m1.m31 = values[3][1];
m1.m32 = values[3][2];
m1.m33 = values[3][3];
}
}
/**
* Places the values in the upper 4x4 of this GMatrix into
* the matrix m1.
* @param m1 The matrix that will hold the new values
*/
public final void get(Matrix4f m1)
{
if (nRow < 4 || nCol < 4) {
m1.setZero();
if (nCol > 0) {
if (nRow > 0) {
m1.m00 = (float)values[0][0];
if (nRow > 1) {
m1.m10 = (float)values[1][0];
if (nRow > 2) {
m1.m20 = (float)values[2][0];
if (nRow > 3) {
m1.m30 = (float)values[3][0];
}
}
}
}
if (nCol > 1) {
if (nRow > 0) {
m1.m01 = (float)values[0][1];
if (nRow > 1) {
m1.m11 = (float)values[1][1];
if (nRow > 2) {
m1.m21 = (float)values[2][1];
if (nRow > 3) {
m1.m31 = (float)values[3][1];
}
}
}
}
if (nCol > 2) {
if (nRow > 0) {
m1.m02 = (float)values[0][2];
if (nRow > 1) {
m1.m12 = (float)values[1][2];
if (nRow > 2) {
m1.m22 = (float)values[2][2];
if (nRow > 3) {
m1.m32 = (float)values[3][2];
}
}
}
}
if (nCol > 3) {
if (nRow > 0) {
m1.m03 = (float)values[0][3];
if (nRow > 1) {
m1.m13 = (float)values[1][3];
if (nRow > 2) {
m1.m23 = (float)values[2][3];
if (nRow > 3) {
m1.m33 = (float)values[3][3];
}
}
}
}
}
}
}
}
} else {
m1.m00 = (float)values[0][0];
m1.m01 = (float)values[0][1];
m1.m02 = (float)values[0][2];
m1.m03 = (float)values[0][3];
m1.m10 = (float)values[1][0];
m1.m11 = (float)values[1][1];
m1.m12 = (float)values[1][2];
m1.m13 = (float)values[1][3];
m1.m20 = (float)values[2][0];
m1.m21 = (float)values[2][1];
m1.m22 = (float)values[2][2];
m1.m23 = (float)values[2][3];
m1.m30 = (float)values[3][0];
m1.m31 = (float)values[3][1];
m1.m32 = (float)values[3][2];
m1.m33 = (float)values[3][3];
}
}
/**
* Places the values in the this GMatrix into the matrix m1;
* m1 should be at least as large as this GMatrix.
* @param m1 The matrix that will hold the new values
*/
public final void get(GMatrix m1)
{
int i, j, nc, nr;
if (nCol < m1.nCol)
nc = nCol;
else
nc = m1.nCol;
if (nRow < m1.nRow)
nr = nRow;
else
nr = m1.nRow;
for (i = 0; i < nr; i++) {
for (j = 0; j < nc; j++) {
m1.values[i][j] = values[i][j];
}
}
for (i = nr; i < m1.nRow; i++) {
for (j = 0; j < m1.nCol; j++) {
m1.values[i][j] = 0.0;
}
}
for (j = nc; j < m1.nCol; j++) {
for (i = 0; i < nr; i++) {
m1.values[i][j] = 0.0;
}
}
}
/**
* Copy the values from the array into the specified row of this
* matrix.
* @param row the row of this matrix into which the array values
* will be copied.
* @param array the source array
*/
public final void setRow(int row, double[] array)
{
for (int i = 0; i < nCol; i++) {
values[row][i] = array[i];
}
}
/**
* Copy the values from the vector into the specified row of this
* matrix.
* @param row the row of this matrix into which the array values
* will be copied
* @param vector the source vector
*/
public final void setRow(int row, GVector vector)
{
for(int i = 0; i < nCol; i++) {
values[row][i] = vector.values[i];
}
}
/**
* Copy the values from the array into the specified column of this
* matrix.
* @param col the column of this matrix into which the array values
* will be copied
* @param array the source array
*/
public final void setColumn(int col, double[] array)
{
for(int i = 0; i < nRow; i++) {
values[i][col] = array[i];
}
}
/**
* Copy the values from the vector into the specified column of this
* matrix.
* @param col the column of this matrix into which the array values
* will be copied
* @param vector the source vector
*/
public final void setColumn(int col, GVector vector)
{
for(int i = 0; i < nRow; i++) {
values[i][col] = vector.values[i];
}
}
/**
* Multiplies the transpose of matrix m1 times the transpose of matrix
* m2, and places the result into this.
* @param m1 The matrix on the left hand side of the multiplication
* @param m2 The matrix on the right hand side of the multiplication
*/
public final void mulTransposeBoth(GMatrix m1, GMatrix m2)
{
int i, j, k;
if (m1.nRow != m2.nCol || nRow != m1.nCol || nCol != m2.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix14"));
if (m1 == this || m2 == this) {
double[][] tmp = new double[nRow][nCol];
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
tmp[i][j] = 0.0;
for (k = 0; k < m1.nRow; k++) {
tmp[i][j] += m1.values[k][i]*m2.values[j][k];
}
}
}
values = tmp;
} else {
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = 0.0;
for (k = 0; k < m1.nRow; k++) {
values[i][j] += m1.values[k][i]*m2.values[j][k];
}
}
}
}
}
/**
* Multiplies matrix m1 times the transpose of matrix m2, and
* places the result into this.
* @param m1 The matrix on the left hand side of the multiplication
* @param m2 The matrix on the right hand side of the multiplication
*/
public final void mulTransposeRight(GMatrix m1, GMatrix m2)
{
int i, j, k;
if (m1.nCol != m2.nCol || nCol != m2.nRow || nRow != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix15"));
if (m1 == this || m2 == this) {
double[][] tmp = new double[nRow][nCol];
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
tmp[i][j] = 0.0;
for (k = 0; k < m1.nCol; k++) {
tmp[i][j] += m1.values[i][k]*m2.values[j][k];
}
}
}
values = tmp;
} else {
for (i = 0; i < nRow; i++) {
for (j = 0;j < nCol; j++) {
values[i][j] = 0.0;
for (k = 0; k < m1.nCol; k++) {
values[i][j] += m1.values[i][k]*m2.values[j][k];
}
}
}
}
}
/**
* Multiplies the transpose of matrix m1 times matrix m2, and
* places the result into this.
* @param m1 The matrix on the left hand side of the multiplication
* @param m2 The matrix on the right hand side of the multiplication
*/
public final void mulTransposeLeft(GMatrix m1, GMatrix m2)
{
int i, j, k;
if (m1.nRow != m2.nRow || nCol != m2.nCol || nRow != m1.nCol)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix16"));
if (m1 == this || m2 == this) {
double[][] tmp = new double[nRow][nCol];
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
tmp[i][j] = 0.0;
for (k = 0; k < m1.nRow; k++) {
tmp[i][j] += m1.values[k][i]*m2.values[k][j];
}
}
}
values = tmp;
} else {
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = 0.0;
for (k = 0; k < m1.nRow; k++) {
values[i][j] += m1.values[k][i]*m2.values[k][j];
}
}
}
}
}
/**
* Transposes this matrix in place.
*/
public final void transpose()
{
int i, j;
if (nRow != nCol) {
double[][] tmp;
i=nRow;
nRow = nCol;
nCol = i;
tmp = new double[nRow][nCol];
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
tmp[i][j] = values[j][i];
}
}
values = tmp;
} else {
double swap;
for (i = 0; i < nRow; i++) {
for (j = 0; j < i; j++) {
swap = values[i][j];
values[i][j] = values[j][i];
values[j][i] = swap;
}
}
}
}
/**
* Places the matrix values of the transpose of matrix m1 into this matrix.
* @param m1 the matrix to be transposed (but not modified)
*/
public final void transpose(GMatrix m1)
{
int i, j;
if (nRow != m1.nCol || nCol != m1.nRow)
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix17"));
if (m1 != this) {
for (i = 0; i < nRow; i++) {
for (j = 0;j < nCol; j++) {
values[i][j] = m1.values[j][i];
}
}
} else {
transpose();
}
}
/**
* Returns a string that contains the values of this GMatrix.
* @return the String representation
*/
public String toString()
{
StringBuffer buffer = new StringBuffer(nRow*nCol*8);
int i, j;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
buffer.append(values[i][j]).append(" ");
}
buffer.append("\n");
}
return buffer.toString();
}
private static void checkMatrix( GMatrix m)
{
int i, j;
for (i = 0; i < m.nRow; i++) {
for (j = 0; j < m.nCol; j++) {
if (Math.abs(m.values[i][j]) < 0.0000000001) {
System.out.print(" 0.0 ");
} else {
System.out.print(" " + m.values[i][j]);
}
}
System.out.print("\n");
}
}
/**
* Returns a hash code value based on the data values in this
* object. Two different GMatrix objects with identical data
* values (i.e., GMatrix.equals returns true) will return the
* same hash number. Two GMatrix objects with different data
* members may return the same hash value, although this is not
* likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + (long)nRow;
bits = 31L * bits + (long)nCol;
for (int i = 0; i < nRow; i++) {
for (int j = 0; j < nCol; j++) {
bits = 31L * bits + VecMathUtil.doubleToLongBits(values[i][j]);
}
}
return (int) (bits ^ (bits >> 32));
}
/**
* Returns true if all of the data members of GMatrix m1 are
* equal to the corresponding data members in this GMatrix.
* @param m1 The matrix with which the comparison is made.
* @return true or false
*/
public boolean equals(GMatrix m1)
{
try {
int i, j;
if (nRow != m1.nRow || nCol != m1.nCol)
return false;
for (i = 0;i < nRow; i++) {
for (j = 0; j < nCol; j++) {
if (values[i][j] != m1.values[i][j])
return false;
}
}
return true;
}
catch (NullPointerException e2) {
return false;
}
}
/**
* Returns true if the Object o1 is of type GMatrix and all of the
* data members of o1 are equal to the corresponding data members in
* this GMatrix.
* @param o1 The object with which the comparison is made.
* @return true or false
*/
public boolean equals(Object o1)
{
try {
GMatrix m2 = (GMatrix) o1;
int i, j;
if (nRow != m2.nRow || nCol != m2.nCol)
return false;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
if (values[i][j] != m2.values[i][j])
return false;
}
}
return true;
}
catch (ClassCastException e1) {
return false;
}
catch (NullPointerException e2) {
return false;
}
}
/**
* @deprecated Use epsilonEquals(GMatrix, double) instead
*/
public boolean epsilonEquals(GMatrix m1, float epsilon) {
return epsilonEquals(m1, (double)epsilon);
}
/**
* Returns true if the L-infinite distance between this matrix
* and matrix m1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to
* MAX[i=0,1,2, . . .n ; j=0,1,2, . . .n ; abs(this.m(i,j) - m1.m(i,j)]
* @param m1 The matrix to be compared to this matrix
* @param epsilon the threshold value
*/
public boolean epsilonEquals(GMatrix m1, double epsilon)
{
int i, j;
double diff;
if (nRow != m1.nRow || nCol != m1.nCol)
return false;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
diff = values[i][j] - m1.values[i][j];
if ((diff < 0 ? -diff : diff) > epsilon)
return false;
}
}
return true;
}
/**
* Returns the trace of this matrix.
* @return the trace of this matrix
*/
public final double trace()
{
int i, l;
double t;
if (nRow < nCol)
l = nRow;
else
l = nCol;
t = 0.0;
for (i = 0; i < l; i++) {
t += values[i][i];
}
return t;
}
/**
* Finds the singular value decomposition (SVD) of this matrix
* such that this = U*W*transpose(V); and returns the rank of
* this matrix; the values of U,W,V are all overwritten. Note
* that the matrix V is output as V, and
* not transpose(V). If this matrix is mxn, then U is mxm, W
* is a diagonal matrix that is mxn, and V is nxn. Using the
* notation W = diag(w), then the inverse of this matrix is:
* inverse(this) = V*diag(1/w)*tranpose(U), where diag(1/w)
* is the same matrix as W except that the reciprocal of each
* of the diagonal components is used.
* @param U The computed U matrix in the equation this = U*W*transpose(V)
* @param W The computed W matrix in the equation this = U*W*transpose(V)
* @param V The computed V matrix in the equation this = U*W*transpose(V)
* @return The rank of this matrix.
*/
public final int SVD(GMatrix U, GMatrix W, GMatrix V)
{
// check for consistancy in dimensions
if (nCol != V.nCol || nCol != V.nRow) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix18"));
}
if (nRow != U.nRow || nRow != U.nCol) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix25"));
}
if (nRow != W.nRow || nCol != W.nCol) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix26"));
}
// Fix ArrayIndexOutOfBounds for 2x2 matrices, which partially
// addresses bug 4348562 for J3D 1.2.1.
//
// Does *not* fix the following problems reported in 4348562,
// which will wait for J3D 1.3:
//
// 1) no output of W
// 2) wrong transposition of U
// 3) wrong results for 4x4 matrices
// 4) slow performance
if (nRow == 2 && nCol == 2) {
if (values[1][0] == 0.0) {
U.setIdentity();
V.setIdentity();
if (values[0][1] == 0.0) {
return 2;
}
double[] sinl = new double[1];
double[] sinr = new double[1];
double[] cosl = new double[1];
double[] cosr = new double[1];
double[] single_values = new double[2];
single_values[0] = values[0][0];
single_values[1] = values[1][1];
compute_2X2(values[0][0], values[0][1], values[1][1],
single_values, sinl, cosl, sinr, cosr, 0);
update_u(0, U, cosl, sinl);
update_v(0, V, cosr, sinr);
return 2;
}
// else call computeSVD() and check for 2x2 there
}
return computeSVD(this, U, W, V);
}
/**
* LU Decomposition: this matrix must be a square matrix and the
* LU GMatrix parameter must be the same size as this matrix.
* The matrix LU will be overwritten as the combination of a
* lower diagonal and upper diagonal matrix decompostion of this
* matrix; the diagonal
* elements of L (unity) are not stored. The GVector parameter
* records the row permutation effected by the partial pivoting,
* and is used as a parameter to the GVector method LUDBackSolve
* to solve sets of linear equations.
* This method returns +/- 1 depending on whether the number
* of row interchanges was even or odd, respectively.
* @param LU The matrix into which the lower and upper decompositions
* will be placed.
* @param permutation The row permutation effected by the partial
* pivoting
* @return +-1 depending on whether the number of row interchanges
* was even or odd respectively
*/
public final int LUD(GMatrix LU, GVector permutation)
{
int size = LU.nRow*LU.nCol;
double[] temp = new double[size];
int[] even_row_exchange = new int[1];
int[] row_perm = new int[LU.nRow];
int i, j;
if (nRow != nCol) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix19"));
}
if (nRow != LU.nRow) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix27"));
}
if (nCol != LU.nCol) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix27"));
}
if (LU.nRow != permutation.getSize()) {
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix20"));
}
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
temp[i*nCol+j] = values[i][j];
}
}
// Calculate LU decomposition: Is the matrix singular?
if (!luDecomposition(LU.nRow, temp, row_perm, even_row_exchange)) {
// Matrix has no inverse
throw new SingularMatrixException
(VecMathI18N.getString("GMatrix21"));
}
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
LU.values[i][j] = temp[i*nCol+j];
}
}
for (i = 0; i < LU.nRow; i++){
permutation.values[i] = (double)row_perm[i];
}
return even_row_exchange[0];
}
/**
* Sets this matrix to a uniform scale matrix; all of the
* values are reset.
* @param scale The new scale value
*/
public final void setScale(double scale)
{
int i, j, l;
if (nRow < nCol)
l = nRow;
else
l = nCol;
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = 0.0;
}
}
for (i = 0; i < l; i++) {
values[i][i] = scale;
}
}
/**
* General invert routine. Inverts m1 and places the result in "this".
* Note that this routine handles both the "this" version and the
* non-"this" version.
*
* Also note that since this routine is slow anyway, we won't worry
* about allocating a little bit of garbage.
*/
final void invertGeneral(GMatrix m1) {
int size = m1.nRow*m1.nCol;
double temp[] = new double[size];
double result[] = new double[size];
int row_perm[] = new int[m1.nRow];
int[] even_row_exchange = new int[1];
int i, j;
// Use LU decomposition and backsubstitution code specifically
// for floating-point nxn matrices.
if (m1.nRow != m1.nCol) {
// Matrix is either under or over determined
throw new MismatchedSizeException
(VecMathI18N.getString("GMatrix22"));
}
// Copy source matrix to temp
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
temp[i*nCol+j] = m1.values[i][j];
}
}
// Calculate LU decomposition: Is the matrix singular?
if (!luDecomposition(m1.nRow, temp, row_perm, even_row_exchange)) {
// Matrix has no inverse
throw new SingularMatrixException
(VecMathI18N.getString("GMatrix21"));
}
// Perform back substitution on the identity matrix
for (i = 0; i < size; i++)
result[i] = 0.0;
for (i = 0; i < nCol; i++)
result[i+i*nCol] = 1.0;
luBacksubstitution(m1.nRow, temp, row_perm, result);
for (i = 0; i < nRow; i++) {
for (j = 0; j < nCol; j++) {
values[i][j] = result[i*nCol+j];
}
}
}
/**
* Given a nxn array "matrix0", this function replaces it with the
* LU decomposition of a row-wise permutation of itself. The input
* parameters are "matrix0" and "dim". The array "matrix0" is also
* an output parameter. The vector "row_perm[]" is an output
* parameter that contains the row permutations resulting from partial
* pivoting. The output parameter "even_row_xchg" is 1 when the
* number of row exchanges is even, or -1 otherwise. Assumes data
* type is always double.
*
* @return true if the matrix is nonsingular, or false otherwise.
*/
//
// Reference: Press, Flannery, Teukolsky, Vetterling,
// _Numerical_Recipes_in_C_, Cambridge University Press,
// 1988, pp 40-45.
//
static boolean luDecomposition(int dim, double[] matrix0,
int[] row_perm, int[] even_row_xchg) {
double row_scale[] = new double[dim];
// Determine implicit scaling information by looping over rows
int i, j;
int ptr, rs, mtx;
double big, temp;
ptr = 0;
rs = 0;
even_row_xchg[0] = 1;
// For each row ...
i = dim;
while (i-- != 0) {
big = 0.0;
// For each column, find the largest element in the row
j = dim;
while (j-- != 0) {
temp = matrix0[ptr++];
temp = Math.abs(temp);
if (temp > big) {
big = temp;
}
}
// Is the matrix singular?
if (big == 0.0) {
return false;
}
row_scale[rs++] = 1.0 / big;
}
// For all columns, execute Crout's method
mtx = 0;
for (j = 0; j < dim; j++) {
int imax, k;
int target, p1, p2;
double sum;
// Determine elements of upper diagonal matrix U
for (i = 0; i < j; i++) {
target = mtx + (dim*i) + j;
sum = matrix0[target];
k = i;
p1 = mtx + (dim*i);
p2 = mtx + j;
while (k-- != 0) {
sum -= matrix0[p1] * matrix0[p2];
p1++;
p2 += dim;
}
matrix0[target] = sum;
}
// Search for largest pivot element and calculate
// intermediate elements of lower diagonal matrix L.
big = 0.0;
imax = -1;
for (i = j; i < dim; i++) {
target = mtx + (dim*i) + j;
sum = matrix0[target];
k = j;
p1 = mtx + (dim*i);
p2 = mtx + j;
while (k-- != 0) {
sum -= matrix0[p1] * matrix0[p2];
p1++;
p2 += dim;
}
matrix0[target] = sum;
// Is this the best pivot so far?
if ((temp = row_scale[i] * Math.abs(sum)) >= big) {
big = temp;
imax = i;
}
}
if (imax < 0) {
throw new RuntimeException(VecMathI18N.getString("GMatrix24"));
}
// Is a row exchange necessary?
if (j != imax) {
// Yes: exchange rows
k = dim;
p1 = mtx + (dim*imax);
p2 = mtx + (dim*j);
while (k-- != 0) {
temp = matrix0[p1];
matrix0[p1++] = matrix0[p2];
matrix0[p2++] = temp;
}
// Record change in scale factor
row_scale[imax] = row_scale[j];
even_row_xchg[0] = -even_row_xchg[0]; // change exchange parity
}
// Record row permutation
row_perm[j] = imax;
// Is the matrix singular
if (matrix0[(mtx + (dim*j) + j)] == 0.0) {
return false;
}
// Divide elements of lower diagonal matrix L by pivot
if (j != (dim-1)) {
temp = 1.0 / (matrix0[(mtx + (dim*j) + j)]);
target = mtx + (dim*(j+1)) + j;
i = (dim-1) - j;
while (i-- != 0) {
matrix0[target] *= temp;
target += dim;
}
}
}
return true;
}
/**
* Solves a set of linear equations. The input parameters "matrix1",
* and "row_perm" come from luDecompostion and do not change
* here. The parameter "matrix2" is a set of column vectors assembled
* into a nxn matrix of floating-point values. The procedure takes each
* column of "matrix2" in turn and treats it as the right-hand side of the
* matrix equation Ax = LUx = b. The solution vector replaces the
* original column of the matrix.
*
* If "matrix2" is the identity matrix, the procedure replaces its contents
* with the inverse of the matrix from which "matrix1" was originally
* derived.
*/
//
// Reference: Press, Flannery, Teukolsky, Vetterling,
// _Numerical_Recipes_in_C_, Cambridge University Press,
// 1988, pp 44-45.
//
static void luBacksubstitution(int dim, double[] matrix1,
int[] row_perm,
double[] matrix2) {
int i, ii, ip, j, k;
int rp;
int cv, rv, ri;
double tt;
// rp = row_perm;
rp = 0;
// For each column vector of matrix2 ...
for (k = 0; k < dim; k++) {
// cv = &(matrix2[0][k]);
cv = k;
ii = -1;
// Forward substitution
for (i = 0; i < dim; i++) {
double sum;
ip = row_perm[rp+i];
sum = matrix2[cv+dim*ip];
matrix2[cv+dim*ip] = matrix2[cv+dim*i];
if (ii >= 0) {
// rv = &(matrix1[i][0]);
rv = i*dim;
for (j = ii; j <= i-1; j++) {
sum -= matrix1[rv+j] * matrix2[cv+dim*j];
}
}
else if (sum != 0.0) {
ii = i;
}
matrix2[cv+dim*i] = sum;
}
// Backsubstitution
for (i = 0; i < dim; i++) {
ri = (dim-1-i);
rv = dim*(ri);
tt = 0.0;
for(j=1;j<=i;j++) {
tt += matrix1[rv+dim-j] * matrix2[cv+dim*(dim-j)];
}
matrix2[cv+dim*ri]= (matrix2[cv+dim*ri] - tt) / matrix1[rv+ri];
}
}
}
static int computeSVD(GMatrix mat, GMatrix U, GMatrix W, GMatrix V) {
int i, j, k;
int nr, nc, si;
int converged, rank;
double cs, sn, r, mag,scale, t;
int eLength, sLength, vecLength;
GMatrix tmp = new GMatrix(mat.nRow, mat.nCol);
GMatrix u = new GMatrix(mat.nRow, mat.nCol);
GMatrix v = new GMatrix(mat.nRow, mat.nCol);
GMatrix m = new GMatrix(mat);
// compute the number of singular values
if (m.nRow >= m.nCol) {
sLength = m.nCol;
eLength = m.nCol-1;
}else {
sLength = m.nRow;
eLength = m.nRow;
}
if (m.nRow > m.nCol)
vecLength = m.nRow;
else
vecLength = m.nCol;
double[] vec = new double[vecLength];
double[] single_values = new double[sLength];
double[] e = new double[eLength];
if(debug) {
System.out.println("input to compute_svd = \n"+m.toString());
}
rank = 0;
U.setIdentity();
V.setIdentity();
nr = m.nRow;
nc = m.nCol;
// householder reduction
for (si = 0; si < sLength; si++) {
// for each singular value
if (nr > 1) {
// zero out column
if (debug)
System.out.println
("*********************** U ***********************\n");
// compute reflector
mag = 0.0;
for (i = 0; i < nr; i++) {
mag += m.values[i+si][si] * m.values[i+si][si];
if (debug)
System.out.println
("mag = " + mag + " matrix.dot = " +
m.values[i+si][si] * m.values[i+si][si]);
}
mag = Math.sqrt(mag);
if (m.values[si][si] == 0.0) {
vec[0] = mag;
} else {
vec[0] = m.values[si][si] + d_sign(mag, m.values[si][si]);
}
for (i = 1; i < nr; i++) {
vec[i] = m.values[si+i][si];
}
scale = 0.0;
for (i = 0; i < nr; i++) {
if (debug)
System.out.println("vec["+i+"]="+vec[i]);
scale += vec[i]*vec[i];
}
scale = 2.0/scale;
if (debug)
System.out.println("scale = "+scale);
for (j = si; j < m.nRow; j++) {
for (k = si; k < m.nRow; k++) {
u.values[j][k] = -scale * vec[j-si]*vec[k-si];
}
}
for (i = si; i < m.nRow; i++){
u.values[i][i] += 1.0;
}
// compute s
t = 0.0;
for (i = si; i < m.nRow; i++){
t += u.values[si][i] * m.values[i][si];
}
m.values[si][si] = t;
// apply reflector
for (j = si; j < m.nRow; j++) {
for (k = si+1; k < m.nCol; k++) {
tmp.values[j][k] = 0.0;
for (i = si; i < m.nCol; i++) {
tmp.values[j][k] += u.values[j][i] * m.values[i][k];
}
}
}
for (j = si; j < m.nRow; j++) {
for (k = si+1; k < m.nCol; k++) {
m.values[j][k] = tmp.values[j][k];
}
}
if (debug) {
System.out.println("U =\n" + U.toString());
System.out.println("u =\n" + u.toString());
}
// update U matrix
for (j = si; j < m.nRow; j++) {
for (k = 0; k < m.nCol; k++) {
tmp.values[j][k] = 0.0;
for (i = si; i < m.nCol; i++) {
tmp.values[j][k] += u.values[j][i] * U.values[i][k];
}
}
}
for (j = si; j < m.nRow; j++) {
for (k = 0; k < m.nCol; k++) {
U.values[j][k] = tmp.values[j][k];
}
}
if (debug) {
System.out.println("single_values["+si+"] =\n" +
single_values[si]);
System.out.println("m =\n" + m.toString());
System.out.println("U =\n" + U.toString());
}
nr--;
}
if( nc > 2 ) {
// zero out row
if (debug)
System.out.println
("*********************** V ***********************\n");
mag = 0.0;
for (i = 1; i < nc; i++){
mag += m.values[si][si+i] * m.values[si][si+i];
}
if (debug)
System.out.println("mag = " + mag);
// generate the reflection vector, compute the first entry and
// copy the rest from the row to be zeroed
mag = Math.sqrt(mag);
if (m.values[si][si+1] == 0.0) {
vec[0] = mag;
} else {
vec[0] = m.values[si][si+1] +
d_sign(mag, m.values[si][si+1]);
}
for (i = 1; i < nc - 1; i++){
vec[i] = m.values[si][si+i+1];
}
// use reflection vector to compute v matrix
scale = 0.0;
for (i = 0; i < nc - 1; i++){
if( debug )System.out.println("vec["+i+"]="+vec[i]);
scale += vec[i]*vec[i];
}
scale = 2.0/scale;
if (debug)
System.out.println("scale = "+scale);
for (j = si + 1; j < nc; j++) {
for (k = si+1; k < m.nCol; k++) {
v.values[j][k] = -scale * vec[j-si-1]*vec[k-si-1];
}
}
for (i = si + 1; i < m.nCol; i++){
v.values[i][i] += 1.0;
}
t=0.0;
for (i = si; i < m.nCol; i++){
t += v.values[i][si+1] * m.values[si][i];
}
m.values[si][si+1]=t;
// apply reflector
for (j = si + 1; j < m.nRow; j++) {
for (k = si + 1; k < m.nCol; k++) {
tmp.values[j][k] = 0.0;
for (i = si + 1; i < m.nCol; i++) {
tmp.values[j][k] += v.values[i][k] * m.values[j][i];
}
}
}
for (j = si + 1; j < m.nRow; j++) {
for (k = si + 1; k < m.nCol; k++) {
m.values[j][k] = tmp.values[j][k];
}
}
if (debug) {
System.out.println("V =\n" + V.toString());
System.out.println("v =\n" + v.toString());
System.out.println("tmp =\n" + tmp.toString());
}
// update V matrix
for (j = 0; j < m.nRow; j++) {
for (k = si + 1; k < m.nCol; k++) {
tmp.values[j][k] = 0.0;
for (i = si + 1; i < m.nCol; i++) {
tmp.values[j][k] += v.values[i][k] * V.values[j][i];
}
}
}
if (debug)
System.out.println("tmp =\n" + tmp.toString());
for (j = 0;j < m.nRow; j++) {
for (k = si + 1; k < m.nCol; k++) {
V.values[j][k] = tmp.values[j][k];
}
}
if (debug) {
System.out.println("m =\n" + m.toString());
System.out.println("V =\n" + V.toString());
}
nc--;
}
}
for (i = 0; i < sLength; i++){
single_values[i] = m.values[i][i];
}
for (i = 0; i < eLength; i++){
e[i] = m.values[i][i+1];
}
// Fix ArrayIndexOutOfBounds for 2x2 matrices, which partially
// addresses bug 4348562 for J3D 1.2.1.
//
// Does *not* fix the following problems reported in 4348562,
// which will wait for J3D 1.3:
//
// 1) no output of W
// 2) wrong transposition of U
// 3) wrong results for 4x4 matrices
// 4) slow performance
if (m.nRow == 2 && m.nCol == 2) {
double[] cosl = new double[1];
double[] cosr = new double[1];
double[] sinl = new double[1];
double[] sinr = new double[1];
compute_2X2(single_values[0], e[0], single_values[1],
single_values, sinl, cosl, sinr, cosr, 0);
update_u(0, U, cosl, sinl);
update_v(0, V, cosr, sinr);
return 2;
}
// compute_qr causes ArrayIndexOutOfBounds for 2x2 matrices
compute_qr (0, e.length-1, single_values, e, U, V);
// compute rank = number of non zero singular values
rank = single_values.length;
// sort by order of size of single values
// and check for zero's
return rank;
}
static void compute_qr(int start, int end, double[] s, double[] e,
GMatrix u, GMatrix v) {
int i, j, k, n, sl;
boolean converged;
double shift, r, utemp, vtemp, f, g;
double[] cosl = new double[1];
double[] cosr = new double[1];
double[] sinl = new double[1];
double[] sinr = new double[1];
GMatrix m = new GMatrix(u.nCol, v.nRow);
final int MAX_INTERATIONS = 2;
final double CONVERGE_TOL = 4.89E-15;
if (debug) {
System.out.println("start =" + start);
System.out.println("s =\n");
for(i=0;i
* Java 3D assumes that a linear (gamma-corrected) visual is used for
* all colors.
*
*/
public class Color3f extends Tuple3f implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = -1861792981817493659L;
/**
* Constructs and initializes a Color3f from the three xyz values.
* @param x the red color value
* @param y the green color value
* @param z the blue color value
*/
public Color3f(float x, float y, float z) {
super(x,y,z);
}
/**
* Constructs and initializes a Color3f from the array of length 3.
* @param v the array of length 3 containing xyz in order
*/
public Color3f(float[] v) {
super(v);
}
/**
* Constructs and initializes a Color3f from the specified Color3f.
* @param v1 the Color3f containing the initialization x y z data
*/
public Color3f(Color3f v1) {
super(v1);
}
/**
* Constructs and initializes a Color3f from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public Color3f(Tuple3f t1) {
super(t1);
}
/**
* Constructs and initializes a Color3f from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public Color3f(Tuple3d t1) {
super(t1);
}
/**
* Constructs and initializes a Color3f from the specified AWT
* Color object. The alpha value of the AWT color is ignored.
* No conversion is done on the color to compensate for
* gamma correction.
*
* @param color the AWT color with which to initialize this
* Color3f object
*
* @since vecmath 1.2
*/
public Color3f(Color color) {
super((float)color.getRed() / 255.0f,
(float)color.getGreen() / 255.0f,
(float)color.getBlue() / 255.0f);
}
/**
* Constructs and initializes a Color3f to (0.0, 0.0, 0.0).
*/
public Color3f() {
super();
}
/**
* Sets the r,g,b values of this Color3f object to those of the
* specified AWT Color object.
* No conversion is done on the color to compensate for
* gamma correction.
*
* @param color the AWT color to copy into this Color3f object
*
* @since vecmath 1.2
*/
public final void set(Color color) {
x = (float)color.getRed() / 255.0f;
y = (float)color.getGreen() / 255.0f;
z = (float)color.getBlue() / 255.0f;
}
/**
* Returns a new AWT color object initialized with the r,g,b
* values of this Color3f object.
*
* @return a new AWT Color object
*
* @since vecmath 1.2
*/
public final Color get() {
int r = Math.round(x * 255.0f);
int g = Math.round(y * 255.0f);
int b = Math.round(z * 255.0f);
return new Color(r, g, b);
}
}
source-cvs/vecmath/src/javax/vecmath/Tuple3d.java 0000644 0001750 0001750 00000043062 10761613453 021377 0 ustar jonny jonny /*
* $RCSfile: Tuple3d.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.8 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A generic 3-element tuple that is represented by double-precision
* floating point x,y,z coordinates.
*
*/
public abstract class Tuple3d implements java.io.Serializable, Cloneable {
static final long serialVersionUID = 5542096614926168415L;
/**
* The x coordinate.
*/
public double x;
/**
* The y coordinate.
*/
public double y;
/**
* The z coordinate.
*/
public double z;
/**
* Constructs and initializes a Tuple3d from the specified xyz coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public Tuple3d(double x, double y, double z)
{
this.x = x;
this.y = y;
this.z = z;
}
/**
* Constructs and initializes a Tuple3d from the array of length 3.
* @param t the array of length 3 containing xyz in order
*/
public Tuple3d(double[] t)
{
this.x = t[0];
this.y = t[1];
this.z = t[2];
}
/**
* Constructs and initializes a Tuple3d from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public Tuple3d(Tuple3d t1)
{
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
}
/**
* Constructs and initializes a Tuple3d from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public Tuple3d(Tuple3f t1)
{
this.x = (double) t1.x;
this.y = (double) t1.y;
this.z = (double) t1.z;
}
/**
* Constructs and initializes a Tuple3d to (0,0,0).
*/
public Tuple3d()
{
this.x = (double) 0.0;
this.y = (double) 0.0;
this.z = (double) 0.0;
}
/**
* Sets the value of this tuple to the specified xyz coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public final void set(double x, double y, double z)
{
this.x = x;
this.y = y;
this.z = z;
}
/**
* Sets the value of this tuple to the value of the xyz coordinates
* located in the array of length 3.
* @param t the array of length 3 containing xyz in order
*/
public final void set(double[] t)
{
this.x = t[0];
this.y = t[1];
this.z = t[2];
}
/**
* Sets the value of this tuple to the value of tuple t1.
* @param t1 the tuple to be copied
*/
public final void set(Tuple3d t1)
{
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
}
/**
* Sets the value of this tuple to the value of tuple t1.
* @param t1 the tuple to be copied
*/
public final void set(Tuple3f t1)
{
this.x = (double) t1.x;
this.y = (double) t1.y;
this.z = (double) t1.z;
}
/**
* Copies the x,y,z coordinates of this tuple into the array t
* of length 3.
* @param t the target array
*/
public final void get(double[] t)
{
t[0] = this.x;
t[1] = this.y;
t[2] = this.z;
}
/**
* Copies the x,y,z coordinates of this tuple into the tuple t.
* @param t the Tuple3d object into which the values of this object are copied
*/
public final void get(Tuple3d t)
{
t.x = this.x;
t.y = this.y;
t.z = this.z;
}
/**
* Sets the value of this tuple to the sum of tuples t1 and t2.
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void add(Tuple3d t1, Tuple3d t2)
{
this.x = t1.x + t2.x;
this.y = t1.y + t2.y;
this.z = t1.z + t2.z;
}
/**
* Sets the value of this tuple to the sum of itself and t1.
* @param t1 the other tuple
*/
public final void add(Tuple3d t1)
{
this.x += t1.x;
this.y += t1.y;
this.z += t1.z;
}
/**
* Sets the value of this tuple to the difference of tuples
* t1 and t2 (this = t1 - t2).
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void sub(Tuple3d t1, Tuple3d t2)
{
this.x = t1.x - t2.x;
this.y = t1.y - t2.y;
this.z = t1.z - t2.z;
}
/**
* Sets the value of this tuple to the difference
* of itself and t1 (this = this - t1).
* @param t1 the other tuple
*/
public final void sub(Tuple3d t1)
{
this.x -= t1.x;
this.y -= t1.y;
this.z -= t1.z;
}
/**
* Sets the value of this tuple to the negation of tuple t1.
* @param t1 the source tuple
*/
public final void negate(Tuple3d t1)
{
this.x = -t1.x;
this.y = -t1.y;
this.z = -t1.z;
}
/**
* Negates the value of this tuple in place.
*/
public final void negate()
{
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1.
* @param s the scalar value
* @param t1 the source tuple
*/
public final void scale(double s, Tuple3d t1)
{
this.x = s*t1.x;
this.y = s*t1.y;
this.z = s*t1.z;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself.
* @param s the scalar value
*/
public final void scale(double s)
{
this.x *= s;
this.y *= s;
this.z *= s;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1 and then adds tuple t2 (this = s*t1 + t2).
* @param s the scalar value
* @param t1 the tuple to be multipled
* @param t2 the tuple to be added
*/
public final void scaleAdd(double s, Tuple3d t1, Tuple3d t2)
{
this.x = s*t1.x + t2.x;
this.y = s*t1.y + t2.y;
this.z = s*t1.z + t2.z;
}
/**
* @deprecated Use scaleAdd(double,Tuple3d) instead
*/
public final void scaleAdd(double s, Tuple3f t1) {
scaleAdd(s, new Point3d(t1));
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself and then adds tuple t1 (this = s*this + t1).
* @param s the scalar value
* @param t1 the tuple to be added
*/
public final void scaleAdd(double s, Tuple3d t1) {
this.x = s*this.x + t1.x;
this.y = s*this.y + t1.y;
this.z = s*this.z + t1.z;
}
/**
* Returns a string that contains the values of this Tuple3d.
* The form is (x,y,z).
* @return the String representation
*/
public String toString() {
return "(" + this.x + ", " + this.y + ", " + this.z + ")";
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple3d objects with identical data values
* (i.e., Tuple3d.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + VecMathUtil.doubleToLongBits(x);
bits = 31L * bits + VecMathUtil.doubleToLongBits(y);
bits = 31L * bits + VecMathUtil.doubleToLongBits(z);
return (int) (bits ^ (bits >> 32));
}
/**
* Returns true if all of the data members of Tuple3d t1 are
* equal to the corresponding data members in this Tuple3d.
* @param t1 the tuple with which the comparison is made
* @return true or false
*/
public boolean equals(Tuple3d t1)
{
try {
return(this.x == t1.x && this.y == t1.y && this.z == t1.z);
}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the Object t1 is of type Tuple3d and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple3d.
* @param t1 the Object with which the comparison is made
* @return true or false
*/
public boolean equals(Object t1)
{
try {
Tuple3d t2 = (Tuple3d) t1;
return(this.x == t2.x && this.y == t2.y && this.z == t2.z);
}
catch (ClassCastException e1) {return false;}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the L-infinite distance between this tuple
* and tuple t1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2)].
* @param t1 the tuple to be compared to this tuple
* @param epsilon the threshold value
* @return true or false
*/
public boolean epsilonEquals(Tuple3d t1, double epsilon)
{
double diff;
diff = x - t1.x;
if(Double.isNaN(diff)) return false;
if((diff<0?-diff:diff) > epsilon) return false;
diff = y - t1.y;
if(Double.isNaN(diff)) return false;
if((diff<0?-diff:diff) > epsilon) return false;
diff = z - t1.z;
if(Double.isNaN(diff)) return false;
if((diff<0?-diff:diff) > epsilon) return false;
return true;
}
/**
* @deprecated Use clamp(double,double,Tuple3d) instead
*/
public final void clamp(float min, float max, Tuple3d t) {
clamp((double)min, (double)max, t);
}
/**
* Clamps the tuple parameter to the range [low, high] and
* places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clamp(double min, double max, Tuple3d t) {
if( t.x > max ) {
x = max;
} else if( t.x < min ){
x = min;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else if( t.y < min ){
y = min;
} else {
y = t.y;
}
if( t.z > max ) {
z = max;
} else if( t.z < min ){
z = min;
} else {
z = t.z;
}
}
/**
* @deprecated Use clampMin(double,Tuple3d) instead
*/
public final void clampMin(float min, Tuple3d t) {
clampMin((double)min, t);
}
/**
* Clamps the minimum value of the tuple parameter to the min
* parameter and places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMin(double min, Tuple3d t) {
if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y < min ) {
y = min;
} else {
y = t.y;
}
if( t.z < min ) {
z = min;
} else {
z = t.z;
}
}
/**
* @deprecated Use clampMax(double,Tuple3d) instead
*/
public final void clampMax(float max, Tuple3d t) {
clampMax((double)max, t);
}
/**
* Clamps the maximum value of the tuple parameter to the max
* parameter and places the values into this tuple.
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMax(double max, Tuple3d t) {
if( t.x > max ) {
x = max;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else {
y = t.y;
}
if( t.z > max ) {
z = max;
} else {
z = t.z;
}
}
/**
* Sets each component of the tuple parameter to its absolute
* value and places the modified values into this tuple.
* @param t the source tuple, which will not be modified
*/
public final void absolute(Tuple3d t)
{
x = Math.abs(t.x);
y = Math.abs(t.y);
z = Math.abs(t.z);
}
/**
* @deprecated Use clamp(double,double) instead
*/
public final void clamp(float min, float max) {
clamp((double)min, (double)max);
}
/**
* Clamps this tuple to the range [low, high].
* @param min the lowest value in this tuple after clamping
* @param max the highest value in this tuple after clamping
*/
public final void clamp(double min, double max) {
if( x > max ) {
x = max;
} else if( x < min ){
x = min;
}
if( y > max ) {
y = max;
} else if( y < min ){
y = min;
}
if( z > max ) {
z = max;
} else if( z < min ){
z = min;
}
}
/**
* @deprecated Use clampMin(double) instead
*/
public final void clampMin(float min) {
clampMin((double)min);
}
/**
* Clamps the minimum value of this tuple to the min parameter.
* @param min the lowest value in this tuple after clamping
*/
public final void clampMin(double min) {
if( x < min ) x=min;
if( y < min ) y=min;
if( z < min ) z=min;
}
/**
* @deprecated Use clampMax(double) instead
*/
public final void clampMax(float max) {
clampMax((double)max);
}
/**
* Clamps the maximum value of this tuple to the max parameter.
* @param max the highest value in the tuple after clamping
*/
public final void clampMax(double max) {
if( x > max ) x=max;
if( y > max ) y=max;
if( z > max ) z=max;
}
/**
* Sets each component of this tuple to its absolute value.
*/
public final void absolute()
{
x = Math.abs(x);
y = Math.abs(y);
z = Math.abs(z);
}
/**
* @deprecated Use interpolate(Tuple3d,Tuple3d,double) instead
*/
public final void interpolate(Tuple3d t1, Tuple3d t2, float alpha) {
interpolate(t1, t2, (double)alpha);
}
/**
* Linearly interpolates between tuples t1 and t2 and places the
* result into this tuple: this = (1-alpha)*t1 + alpha*t2.
* @param t1 the first tuple
* @param t2 the second tuple
* @param alpha the alpha interpolation parameter
*/
public final void interpolate(Tuple3d t1, Tuple3d t2, double alpha) {
this.x = (1-alpha)*t1.x + alpha*t2.x;
this.y = (1-alpha)*t1.y + alpha*t2.y;
this.z = (1-alpha)*t1.z + alpha*t2.z;
}
/**
* @deprecated Use interpolate(Tuple3d,double) instead
*/
public final void interpolate(Tuple3d t1, float alpha) {
interpolate(t1, (double)alpha);
}
/**
* Linearly interpolates between this tuple and tuple t1 and
* places the result into this tuple: this = (1-alpha)*this + alpha*t1.
* @param t1 the first tuple
* @param alpha the alpha interpolation parameter
*/
public final void interpolate(Tuple3d t1, double alpha) {
this.x = (1-alpha)*this.x + alpha*t1.x;
this.y = (1-alpha)*this.y + alpha*t1.y;
this.z = (1-alpha)*this.z + alpha*t1.z;
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public final double getX() {
return x;
}
/**
* Set the x coordinate.
*
* @param x value to x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(double x) {
this.x = x;
}
/**
* Get the y coordinate.
*
* @return the y coordinate.
*
* @since vecmath 1.5
*/
public final double getY() {
return y;
}
/**
* Set the y coordinate.
*
* @param y value to y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(double y) {
this.y = y;
}
/**
* Get the z coordinate.
*
* @return the z coordinate.
*
* @since vecmath 1.5
*/
public final double getZ() {
return z;
}
/**
* Set the z coordinate.
*
* @param z value to z coordinate.
*
* @since vecmath 1.5
*/
public final void setZ(double z) {
this.z = z;
}
}
source-cvs/vecmath/src/javax/vecmath/Point2i.java 0000644 0001750 0001750 00000004477 10761613452 021411 0 ustar jonny jonny /*
* $RCSfile: Point2i.java,v $
*
* Copyright 2005-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 2-element point represented by signed integer x,y
* coordinates.
*
* @since vecmath 1.4
*/
public class Point2i extends Tuple2i implements java.io.Serializable {
static final long serialVersionUID = 9208072376494084954L;
/**
* Constructs and initializes a Point2i from the specified
* x and y coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public Point2i(int x, int y) {
super(x, y);
}
/**
* Constructs and initializes a Point2i from the array of length 2.
* @param t the array of length 2 containing x and y in order.
*/
public Point2i(int[] t) {
super(t);
}
/**
* Constructs and initializes a Point2i from the specified Tuple2i.
* @param t1 the Tuple2i containing the initialization x and y
* data.
*/
public Point2i(Tuple2i t1) {
super(t1);
}
/**
* Constructs and initializes a Point2i to (0,0).
*/
public Point2i() {
super();
}
}
source-cvs/vecmath/src/javax/vecmath/Vector2d.java 0000644 0001750 0001750 00000011326 10761613453 021545 0 ustar jonny jonny /*
* $RCSfile: Vector2d.java,v $
*
* Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 2-element vector that is represented by double-precision floating
* point x,y coordinates.
*
*/
public class Vector2d extends Tuple2d implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = 8572646365302599857L;
/**
* Constructs and initializes a Vector2d from the specified xy coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public Vector2d(double x, double y)
{
super(x,y);
}
/**
* Constructs and initializes a Vector2d from the specified array.
* @param v the array of length 2 containing xy in order
*/
public Vector2d(double[] v)
{
super(v);
}
/**
* Constructs and initializes a Vector2d from the specified Vector2d.
* @param v1 the Vector2d containing the initialization x y data
*/
public Vector2d(Vector2d v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector2d from the specified Vector2f.
* @param v1 the Vector2f containing the initialization x y data
*/
public Vector2d(Vector2f v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector2d from the specified Tuple2d.
* @param t1 the Tuple2d containing the initialization x y data
*/
public Vector2d(Tuple2d t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector2d from the specified Tuple2f.
* @param t1 the Tuple2f containing the initialization x y data
*/
public Vector2d(Tuple2f t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector2d to (0,0).
*/
public Vector2d()
{
super();
}
/**
* Computes the dot product of the this vector and vector v1.
* @param v1 the other vector
*/
public final double dot(Vector2d v1)
{
return (this.x*v1.x + this.y*v1.y);
}
/**
* Returns the length of this vector.
* @return the length of this vector
*/
public final double length()
{
return (double) Math.sqrt(this.x*this.x + this.y*this.y);
}
/**
* Returns the squared length of this vector.
* @return the squared length of this vector
*/
public final double lengthSquared()
{
return (this.x*this.x + this.y*this.y);
}
/**
* Sets the value of this vector to the normalization of vector v1.
* @param v1 the un-normalized vector
*/
public final void normalize(Vector2d v1)
{
double norm;
norm = (double) (1.0/Math.sqrt(v1.x*v1.x + v1.y*v1.y));
this.x = v1.x*norm;
this.y = v1.y*norm;
}
/**
* Normalizes this vector in place.
*/
public final void normalize()
{
double norm;
norm = (double)
(1.0/Math.sqrt(this.x*this.x + this.y*this.y));
this.x *= norm;
this.y *= norm;
}
/**
* Returns the angle in radians between this vector and the vector
* parameter; the return value is constrained to the range [0,PI].
* @param v1 the other vector
* @return the angle in radians in the range [0,PI]
*/
public final double angle(Vector2d v1)
{
double vDot = this.dot(v1) / ( this.length()*v1.length() );
if( vDot < -1.0) vDot = -1.0;
if( vDot > 1.0) vDot = 1.0;
return((double) (Math.acos( vDot )));
}
}
source-cvs/vecmath/src/javax/vecmath/Vector4f.java 0000644 0001750 0001750 00000013411 10761613453 021546 0 ustar jonny jonny /*
* $RCSfile: Vector4f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.6 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 4-element vector represented by single-precision floating point x,y,z,w
* coordinates.
*
*/
public class Vector4f extends Tuple4f implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = 8749319902347760659L;
/**
* Constructs and initializes a Vector4f from the specified xyzw coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w coordinate
*/
public Vector4f(float x, float y, float z, float w)
{
super(x,y,z,w);
}
/**
* Constructs and initializes a Vector4f from the array of length 4.
* @param v the array of length 4 containing xyzw in order
*/
public Vector4f(float[] v)
{
super(v);
}
/**
* Constructs and initializes a Vector4f from the specified Vector4f.
* @param v1 the Vector4f containing the initialization x y z w data
*/
public Vector4f(Vector4f v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector4f from the specified Vector4d.
* @param v1 the Vector4d containing the initialization x y z w data
*/
public Vector4f(Vector4d v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector4f from the specified Tuple4f.
* @param t1 the Tuple4f containing the initialization x y z w data
*/
public Vector4f(Tuple4f t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector4f from the specified Tuple4d.
* @param t1 the Tuple4d containing the initialization x y z w data
*/
public Vector4f(Tuple4d t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector4f from the specified Tuple3f.
* The x,y,z components of this vector are set to the corresponding
* components of tuple t1. The w component of this vector
* is set to 0.
* @param t1 the tuple to be copied
*
* @since vecmath 1.2
*/
public Vector4f(Tuple3f t1) {
super(t1.x, t1.y, t1.z, 0.0f);
}
/**
* Constructs and initializes a Vector4f to (0,0,0,0).
*/
public Vector4f()
{
super();
}
/**
* Sets the x,y,z components of this vector to the corresponding
* components of tuple t1. The w component of this vector
* is set to 0.
* @param t1 the tuple to be copied
*
* @since vecmath 1.2
*/
public final void set(Tuple3f t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = 0.0f;
}
/**
* Returns the length of this vector.
* @return the length of this vector as a float
*/
public final float length()
{
return
(float) Math.sqrt(this.x*this.x + this.y*this.y +
this.z*this.z + this.w*this.w);
}
/**
* Returns the squared length of this vector
* @return the squared length of this vector as a float
*/
public final float lengthSquared()
{
return (this.x*this.x + this.y*this.y +
this.z*this.z + this.w*this.w);
}
/**
* returns the dot product of this vector and v1
* @param v1 the other vector
* @return the dot product of this vector and v1
*/
public final float dot(Vector4f v1)
{
return (this.x*v1.x + this.y*v1.y + this.z*v1.z + this.w*v1.w);
}
/**
* Sets the value of this vector to the normalization of vector v1.
* @param v1 the un-normalized vector
*/
public final void normalize(Vector4f v1)
{
float norm;
norm = (float) (1.0/Math.sqrt(v1.x*v1.x + v1.y*v1.y +
v1.z*v1.z + v1.w*v1.w));
this.x = v1.x*norm;
this.y = v1.y*norm;
this.z = v1.z*norm;
this.w = v1.w*norm;
}
/**
* Normalizes this vector in place.
*/
public final void normalize()
{
float norm;
norm = (float) (1.0/Math.sqrt(this.x*this.x + this.y*this.y +
this.z*this.z + this.w*this.w));
this.x *= norm;
this.y *= norm;
this.z *= norm;
this.w *= norm;
}
/**
* Returns the (4-space) angle in radians between this vector and
* the vector parameter; the return value is constrained to the
* range [0,PI].
* @param v1 the other vector
* @return the angle in radians in the range [0,PI]
*/
public final float angle(Vector4f v1)
{
double vDot = this.dot(v1) / ( this.length()*v1.length() );
if( vDot < -1.0) vDot = -1.0;
if( vDot > 1.0) vDot = 1.0;
return((float) (Math.acos( vDot )));
}
}
source-cvs/vecmath/src/javax/vecmath/Point3d.java 0000644 0001750 0001750 00000011645 10761613452 021400 0 ustar jonny jonny /*
* $RCSfile: Point3d.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 3 element point that is represented by double precision floating point
* x,y,z coordinates.
*
*/
public class Point3d extends Tuple3d implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = 5718062286069042927L;
/**
* Constructs and initializes a Point3d from the specified xyz coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public Point3d(double x, double y, double z)
{
super(x,y,z);
}
/**
* Constructs and initializes a Point3d from the array of length 3.
* @param p the array of length 3 containing xyz in order
*/
public Point3d(double[] p)
{
super(p);
}
/**
* Constructs and initializes a Point3d from the specified Point3d.
* @param p1 the Point3d containing the initialization x y z data
*/
public Point3d(Point3d p1)
{
super(p1);
}
/**
* Constructs and initializes a Point3d from the specified Point3f.
* @param p1 the Point3f containing the initialization x y z data
*/
public Point3d(Point3f p1)
{
super(p1);
}
/**
* Constructs and initializes a Point3d from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public Point3d(Tuple3f t1)
{
super(t1);
}
/**
* Constructs and initializes a Point3d from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public Point3d(Tuple3d t1)
{
super(t1);
}
/**
* Constructs and initializes a Point3d to (0,0,0).
*/
public Point3d()
{
super();
}
/**
* Returns the square of the distance between this point and point p1.
* @param p1 the other point
* @return the square of the distance
*/
public final double distanceSquared(Point3d p1)
{
double dx, dy, dz;
dx = this.x-p1.x;
dy = this.y-p1.y;
dz = this.z-p1.z;
return (dx*dx+dy*dy+dz*dz);
}
/**
* Returns the distance between this point and point p1.
* @param p1 the other point
* @return the distance
*/
public final double distance(Point3d p1)
{
double dx, dy, dz;
dx = this.x-p1.x;
dy = this.y-p1.y;
dz = this.z-p1.z;
return Math.sqrt(dx*dx+dy*dy+dz*dz);
}
/**
* Computes the L-1 (Manhattan) distance between this point and
* point p1. The L-1 distance is equal to:
* abs(x1-x2) + abs(y1-y2) + abs(z1-z2).
* @param p1 the other point
* @return the L-1 distance
*/
public final double distanceL1(Point3d p1) {
return Math.abs(this.x-p1.x) + Math.abs(this.y-p1.y) +
Math.abs(this.z-p1.z);
}
/**
* Computes the L-infinite distance between this point and
* point p1. The L-infinite distance is equal to
* MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2)].
* @param p1 the other point
* @return the L-infinite distance
*/
public final double distanceLinf(Point3d p1) {
double tmp;
tmp = Math.max( Math.abs(this.x-p1.x), Math.abs(this.y-p1.y));
return Math.max(tmp,Math.abs(this.z-p1.z));
}
/**
* Multiplies each of the x,y,z components of the Point4d parameter
* by 1/w and places the projected values into this point.
* @param p1 the source Point4d, which is not modified
*/
public final void project(Point4d p1)
{
double oneOw;
oneOw = 1/p1.w;
x = p1.x*oneOw;
y = p1.y*oneOw;
z = p1.z*oneOw;
}
}
source-cvs/vecmath/src/javax/vecmath/Point4f.java 0000644 0001750 0001750 00000013622 10761613452 021400 0 ustar jonny jonny /*
* $RCSfile: Point4f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.6 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 4 element point represented by single precision floating point x,y,z,w
* coordinates.
*
*/
public class Point4f extends Tuple4f implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = 4643134103185764459L;
/**
* Constructs and initializes a Point4f from the specified xyzw coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w coordinate
*/
public Point4f(float x, float y, float z, float w)
{
super(x,y,z,w);
}
/**
* Constructs and initializes a Point4f from the array of length 4.
* @param p the array of length 4 containing xyzw in order
*/
public Point4f(float[] p)
{
super(p);
}
/**
* Constructs and initializes a Point4f from the specified Point4f.
* @param p1 the Point4f containing the initialization x y z w data
*/
public Point4f(Point4f p1)
{
super(p1);
}
/**
* Constructs and initializes a Point4f from the specified Point4d.
* @param p1 the Point4d containing the initialization x y z w data
*/
public Point4f(Point4d p1)
{
super(p1);
}
/**
* Constructs and initializes a Point4f from the specified Tuple4f.
* @param t1 the Tuple4f containing the initialization x y z w data
*/
public Point4f(Tuple4f t1)
{
super(t1);
}
/**
* Constructs and initializes a Point4f from the specified Tuple4d.
* @param t1 the Tuple4d containing the initialization x y z w data
*/
public Point4f(Tuple4d t1)
{
super(t1);
}
/**
* Constructs and initializes a Point4f from the specified Tuple3f.
* The x,y,z components of this point are set to the corresponding
* components of tuple t1. The w component of this point
* is set to 1.
* @param t1 the tuple to be copied
*
* @since vecmath 1.2
*/
public Point4f(Tuple3f t1) {
super(t1.x, t1.y, t1.z, 1.0f);
}
/**
* Constructs and initializes a Point4f to (0,0,0,0).
*/
public Point4f()
{
super();
}
/**
* Sets the x,y,z components of this point to the corresponding
* components of tuple t1. The w component of this point
* is set to 1.
* @param t1 the tuple to be copied
*
* @since vecmath 1.2
*/
public final void set(Tuple3f t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = 1.0f;
}
/**
* Computes the square of the distance between this point and point p1.
* @param p1 the other point
* @return the square of distance between these two points as a float
*/
public final float distanceSquared(Point4f p1)
{
float dx, dy, dz, dw;
dx = this.x-p1.x;
dy = this.y-p1.y;
dz = this.z-p1.z;
dw = this.w-p1.w;
return (dx*dx+dy*dy+dz*dz+dw*dw);
}
/**
* Computes the distance between this point and point p1.
* @param p1 the other point
* @return the distance between the two points
*/
public final float distance(Point4f p1)
{
float dx, dy, dz, dw;
dx = this.x-p1.x;
dy = this.y-p1.y;
dz = this.z-p1.z;
dw = this.w-p1.w;
return (float) Math.sqrt(dx*dx+dy*dy+dz*dz+dw*dw);
}
/**
* Computes the L-1 (Manhattan) distance between this point and
* point p1. The L-1 distance is equal to:
* abs(x1-x2) + abs(y1-y2) + abs(z1-z2) + abs(w1-w2).
* @param p1 the other point
* @return the L-1 distance
*/
public final float distanceL1(Point4f p1)
{
return( Math.abs(this.x-p1.x) + Math.abs(this.y-p1.y) + Math.abs(this.z-p1.z) + Math.abs(this.w-p1.w));
}
/**
* Computes the L-infinite distance between this point and
* point p1. The L-infinite distance is equal to
* MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(w1-w2)].
* @param p1 the other point
* @return the L-infinite distance
*/
public final float distanceLinf(Point4f p1)
{
float t1, t2;
t1 = Math.max( Math.abs(this.x-p1.x), Math.abs(this.y-p1.y));
t2 = Math.max( Math.abs(this.z-p1.z), Math.abs(this.w-p1.w));
return(Math.max(t1,t2));
}
/**
* Multiplies each of the x,y,z components of the Point4f parameter
* by 1/w, places the projected values into this point, and places
* a 1 as the w parameter of this point.
* @param p1 the source Point4f, which is not modified
*/
public final void project(Point4f p1)
{
float oneOw;
oneOw = 1/p1.w;
x = p1.x*oneOw;
y = p1.y*oneOw;
z = p1.z*oneOw;
w = 1.0f;
}
}
source-cvs/vecmath/src/javax/vecmath/Vector4d.java 0000644 0001750 0001750 00000013656 10761613453 021557 0 ustar jonny jonny /*
* $RCSfile: Vector4d.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.6 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 4-element vector represented by double-precision floating point
* x,y,z,w coordinates.
*
*/
public class Vector4d extends Tuple4d implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = 3938123424117448700L;
/**
* Constructs and initializes a Vector4d from the specified xyzw coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w coordinate
*/
public Vector4d(double x, double y, double z, double w)
{
super(x,y,z,w);
}
/**
* Constructs and initializes a Vector4d from the coordinates contained
* in the array.
* @param v the array of length 4 containing xyzw in order
*/
public Vector4d(double[] v)
{
super(v);
}
/**
* Constructs and initializes a Vector4d from the specified Vector4d.
* @param v1 the Vector4d containing the initialization x y z w data
*/
public Vector4d(Vector4d v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector4d from the specified Vector4f.
* @param v1 the Vector4f containing the initialization x y z w data
*/
public Vector4d(Vector4f v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector4d from the specified Tuple4f.
* @param t1 the Tuple4f containing the initialization x y z w data
*/
public Vector4d(Tuple4f t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector4d from the specified Tuple4d.
* @param t1 the Tuple4d containing the initialization x y z w data
*/
public Vector4d(Tuple4d t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector4d from the specified Tuple3d.
* The x,y,z components of this vector are set to the corresponding
* components of tuple t1. The w component of this vector
* is set to 0.
* @param t1 the tuple to be copied
*
* @since vecmath 1.2
*/
public Vector4d(Tuple3d t1) {
super(t1.x, t1.y, t1.z, 0.0);
}
/**
* Constructs and initializes a Vector4d to (0,0,0,0).
*/
public Vector4d()
{
super();
}
/**
* Sets the x,y,z components of this vector to the corresponding
* components of tuple t1. The w component of this vector
* is set to 0.
* @param t1 the tuple to be copied
*
* @since vecmath 1.2
*/
public final void set(Tuple3d t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = 0.0;
}
/**
* Returns the length of this vector.
* @return the length of this vector
*/
public final double length()
{
return Math.sqrt(this.x*this.x + this.y*this.y +
this.z*this.z + this.w*this.w);
}
/**
* Returns the squared length of this vector.
* @return the squared length of this vector
*/
public final double lengthSquared()
{
return (this.x*this.x + this.y*this.y +
this.z*this.z + this.w*this.w);
}
/**
* Returns the dot product of this vector and vector v1.
* @param v1 the other vector
* @return the dot product of this vector and vector v1
*/
public final double dot(Vector4d v1)
{
return (this.x*v1.x + this.y*v1.y + this.z*v1.z + this.w*v1.w);
}
/**
* Sets the value of this vector to the normalization of vector v1.
* @param v1 the un-normalized vector
*/
public final void normalize(Vector4d v1)
{
double norm;
norm = 1.0/Math.sqrt(v1.x*v1.x + v1.y*v1.y + v1.z*v1.z + v1.w*v1.w);
this.x = v1.x*norm;
this.y = v1.y*norm;
this.z = v1.z*norm;
this.w = v1.w*norm;
}
/**
* Normalizes this vector in place.
*/
public final void normalize()
{
double norm;
norm = 1.0/Math.sqrt(this.x*this.x + this.y*this.y +
this.z*this.z + this.w*this.w);
this.x *= norm;
this.y *= norm;
this.z *= norm;
this.w *= norm;
}
/**
* Returns the (4-space) angle in radians between this vector and
* the vector parameter; the return value is constrained to the
* range [0,PI].
* @param v1 the other vector
* @return the angle in radians in the range [0,PI]
*/
public final double angle(Vector4d v1)
{
double vDot = this.dot(v1) / ( this.length()*v1.length() );
if( vDot < -1.0) vDot = -1.0;
if( vDot > 1.0) vDot = 1.0;
return((double) (Math.acos( vDot )));
}
}
source-cvs/vecmath/src/javax/vecmath/Vector3f.java 0000644 0001750 0001750 00000012606 10761613453 021552 0 ustar jonny jonny /*
* $RCSfile: Vector3f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 3-element vector that is represented by single-precision floating point
* x,y,z coordinates. If this value represents a normal, then it should
* be normalized.
*
*/
public class Vector3f extends Tuple3f implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = -7031930069184524614L;
/**
* Constructs and initializes a Vector3f from the specified xyz coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public Vector3f(float x, float y, float z)
{
super(x,y,z);
}
/**
* Constructs and initializes a Vector3f from the array of length 3.
* @param v the array of length 3 containing xyz in order
*/
public Vector3f(float[] v)
{
super(v);
}
/**
* Constructs and initializes a Vector3f from the specified Vector3f.
* @param v1 the Vector3f containing the initialization x y z data
*/
public Vector3f(Vector3f v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector3f from the specified Vector3d.
* @param v1 the Vector3d containing the initialization x y z data
*/
public Vector3f(Vector3d v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector3f from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public Vector3f(Tuple3f t1) {
super(t1);
}
/**
* Constructs and initializes a Vector3f from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public Vector3f(Tuple3d t1) {
super(t1);
}
/**
* Constructs and initializes a Vector3f to (0,0,0).
*/
public Vector3f()
{
super();
}
/**
* Returns the squared length of this vector.
* @return the squared length of this vector
*/
public final float lengthSquared()
{
return (this.x*this.x + this.y*this.y + this.z*this.z);
}
/**
* Returns the length of this vector.
* @return the length of this vector
*/
public final float length()
{
return (float)
Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.z);
}
/**
* Sets this vector to be the vector cross product of vectors v1 and v2.
* @param v1 the first vector
* @param v2 the second vector
*/
public final void cross(Vector3f v1, Vector3f v2)
{
float x,y;
x = v1.y*v2.z - v1.z*v2.y;
y = v2.x*v1.z - v2.z*v1.x;
this.z = v1.x*v2.y - v1.y*v2.x;
this.x = x;
this.y = y;
}
/**
* Computes the dot product of this vector and vector v1.
* @param v1 the other vector
* @return the dot product of this vector and v1
*/
public final float dot(Vector3f v1)
{
return (this.x*v1.x + this.y*v1.y + this.z*v1.z);
}
/**
* Sets the value of this vector to the normalization of vector v1.
* @param v1 the un-normalized vector
*/
public final void normalize(Vector3f v1)
{
float norm;
norm = (float) (1.0/Math.sqrt(v1.x*v1.x + v1.y*v1.y + v1.z*v1.z));
this.x = v1.x*norm;
this.y = v1.y*norm;
this.z = v1.z*norm;
}
/**
* Normalizes this vector in place.
*/
public final void normalize()
{
float norm;
norm = (float)
(1.0/Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.z));
this.x *= norm;
this.y *= norm;
this.z *= norm;
}
/**
* Returns the angle in radians between this vector and the vector
* parameter; the return value is constrained to the range [0,PI].
* @param v1 the other vector
* @return the angle in radians in the range [0,PI]
*/
public final float angle(Vector3f v1)
{
double vDot = this.dot(v1) / ( this.length()*v1.length() );
if( vDot < -1.0) vDot = -1.0;
if( vDot > 1.0) vDot = 1.0;
return((float) (Math.acos( vDot )));
}
}
source-cvs/vecmath/src/javax/vecmath/Tuple4i.java 0000644 0001750 0001750 00000034146 10761613453 021410 0 ustar jonny jonny /*
* $RCSfile: Tuple4i.java,v $
*
* Copyright 1999-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.7 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 4-element tuple represented by signed integer x,y,z,w
* coordinates.
*
* @since vecmath 1.2
*/
public abstract class Tuple4i implements java.io.Serializable, Cloneable {
static final long serialVersionUID = 8064614250942616720L;
/**
* The x coordinate.
*/
public int x;
/**
* The y coordinate.
*/
public int y;
/**
* The z coordinate.
*/
public int z;
/**
* The w coordinate.
*/
public int w;
/**
* Constructs and initializes a Tuple4i from the specified
* x, y, z, and w coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w coordinate
*/
public Tuple4i(int x, int y, int z, int w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/**
* Constructs and initializes a Tuple4i from the array of length 4.
* @param t the array of length 4 containing x, y, z, and w in order.
*/
public Tuple4i(int[] t) {
this.x = t[0];
this.y = t[1];
this.z = t[2];
this.w = t[3];
}
/**
* Constructs and initializes a Tuple4i from the specified Tuple4i.
* @param t1 the Tuple4i containing the initialization x, y, z,
* and w data.
*/
public Tuple4i(Tuple4i t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = t1.w;
}
/**
* Constructs and initializes a Tuple4i to (0,0,0,0).
*/
public Tuple4i() {
this.x = 0;
this.y = 0;
this.z = 0;
this.w = 0;
}
/**
* Sets the value of this tuple to the specified x, y, z, and w
* coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w coordinate
*/
public final void set(int x, int y, int z, int w) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/**
* Sets the value of this tuple to the specified coordinates in the
* array of length 4.
* @param t the array of length 4 containing x, y, z, and w in order.
*/
public final void set(int[] t) {
this.x = t[0];
this.y = t[1];
this.z = t[2];
this.w = t[3];
}
/**
* Sets the value of this tuple to the value of tuple t1.
* @param t1 the tuple to be copied
*/
public final void set(Tuple4i t1) {
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = t1.w;
}
/**
* Copies the values of this tuple into the array t.
* @param t the array
*/
public final void get(int[] t) {
t[0] = this.x;
t[1] = this.y;
t[2] = this.z;
t[3] = this.w;
}
/**
* Copies the values of this tuple into the tuple t.
* @param t the target tuple
*/
public final void get(Tuple4i t) {
t.x = this.x;
t.y = this.y;
t.z = this.z;
t.w = this.w;
}
/**
* Sets the value of this tuple to the sum of tuples t1 and t2.
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void add(Tuple4i t1, Tuple4i t2) {
this.x = t1.x + t2.x;
this.y = t1.y + t2.y;
this.z = t1.z + t2.z;
this.w = t1.w + t2.w;
}
/**
* Sets the value of this tuple to the sum of itself and t1.
* @param t1 the other tuple
*/
public final void add(Tuple4i t1) {
this.x += t1.x;
this.y += t1.y;
this.z += t1.z;
this.w += t1.w;
}
/**
* Sets the value of this tuple to the difference
* of tuples t1 and t2 (this = t1 - t2).
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void sub(Tuple4i t1, Tuple4i t2) {
this.x = t1.x - t2.x;
this.y = t1.y - t2.y;
this.z = t1.z - t2.z;
this.w = t1.w - t2.w;
}
/**
* Sets the value of this tuple to the difference
* of itself and t1 (this = this - t1).
* @param t1 the other tuple
*/
public final void sub(Tuple4i t1) {
this.x -= t1.x;
this.y -= t1.y;
this.z -= t1.z;
this.w -= t1.w;
}
/**
* Sets the value of this tuple to the negation of tuple t1.
* @param t1 the source tuple
*/
public final void negate(Tuple4i t1) {
this.x = -t1.x;
this.y = -t1.y;
this.z = -t1.z;
this.w = -t1.w;
}
/**
* Negates the value of this tuple in place.
*/
public final void negate() {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
this.w = -this.w;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1.
* @param s the scalar value
* @param t1 the source tuple
*/
public final void scale(int s, Tuple4i t1) {
this.x = s*t1.x;
this.y = s*t1.y;
this.z = s*t1.z;
this.w = s*t1.w;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of the scale factor with this.
* @param s the scalar value
*/
public final void scale(int s) {
this.x *= s;
this.y *= s;
this.z *= s;
this.w *= s;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1 plus tuple t2 (this = s*t1 + t2).
* @param s the scalar value
* @param t1 the tuple to be multipled
* @param t2 the tuple to be added
*/
public final void scaleAdd(int s, Tuple4i t1, Tuple4i t2) {
this.x = s*t1.x + t2.x;
this.y = s*t1.y + t2.y;
this.z = s*t1.z + t2.z;
this.w = s*t1.w + t2.w;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself and then adds tuple t1 (this = s*this + t1).
* @param s the scalar value
* @param t1 the tuple to be added
*/
public final void scaleAdd(int s, Tuple4i t1) {
this.x = s*this.x + t1.x;
this.y = s*this.y + t1.y;
this.z = s*this.z + t1.z;
this.w = s*this.w + t1.w;
}
/**
* Returns a string that contains the values of this Tuple4i.
* The form is (x,y,z,w).
* @return the String representation
*/
public String toString() {
return "(" + this.x + ", " + this.y + ", " + this.z + ", " + this.w + ")";
}
/**
* Returns true if the Object t1 is of type Tuple4i and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple4i.
* @param t1 the object with which the comparison is made
* @return true or false
*/
public boolean equals(Object t1) {
try {
Tuple4i t2 = (Tuple4i) t1;
return(this.x == t2.x && this.y == t2.y &&
this.z == t2.z && this.w == t2.w);
}
catch (NullPointerException e2) {
return false;
}
catch (ClassCastException e1) {
return false;
}
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple4i objects with identical data values
* (i.e., Tuple4i.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + (long)x;
bits = 31L * bits + (long)y;
bits = 31L * bits + (long)z;
bits = 31L * bits + (long)w;
return (int) (bits ^ (bits >> 32));
}
/**
* Clamps the tuple parameter to the range [low, high] and
* places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clamp(int min, int max, Tuple4i t) {
if( t.x > max ) {
x = max;
} else if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else if( t.y < min ) {
y = min;
} else {
y = t.y;
}
if( t.z > max ) {
z = max;
} else if( t.z < min ) {
z = min;
} else {
z = t.z;
}
if( t.w > max ) {
w = max;
} else if( t.w < min ) {
w = min;
} else {
w = t.w;
}
}
/**
* Clamps the minimum value of the tuple parameter to the min
* parameter and places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMin(int min, Tuple4i t) {
if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y < min ) {
y = min;
} else {
y = t.y;
}
if( t.z < min ) {
z = min;
} else {
z = t.z;
}
if( t.w < min ) {
w = min;
} else {
w = t.w;
}
}
/**
* Clamps the maximum value of the tuple parameter to the max
* parameter and places the values into this tuple.
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMax(int max, Tuple4i t) {
if( t.x > max ) {
x = max;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else {
y = t.y;
}
if( t.z > max ) {
z = max;
} else {
z = t.z;
}
if( t.w > max ) {
w = max;
} else {
w = t.z;
}
}
/**
* Sets each component of the tuple parameter to its absolute
* value and places the modified values into this tuple.
* @param t the source tuple, which will not be modified
*/
public final void absolute(Tuple4i t) {
x = Math.abs(t.x);
y = Math.abs(t.y);
z = Math.abs(t.z);
w = Math.abs(t.w);
}
/**
* Clamps this tuple to the range [low, high].
* @param min the lowest value in this tuple after clamping
* @param max the highest value in this tuple after clamping
*/
public final void clamp(int min, int max) {
if( x > max ) {
x = max;
} else if( x < min ) {
x = min;
}
if( y > max ) {
y = max;
} else if( y < min ) {
y = min;
}
if( z > max ) {
z = max;
} else if( z < min ) {
z = min;
}
if( w > max ) {
w = max;
} else if( w < min ) {
w = min;
}
}
/**
* Clamps the minimum value of this tuple to the min parameter.
* @param min the lowest value in this tuple after clamping
*/
public final void clampMin(int min) {
if (x < min)
x=min;
if (y < min)
y = min;
if (z < min)
z = min;
if (w < min)
w = min;
}
/**
* Clamps the maximum value of this tuple to the max parameter.
* @param max the highest value in the tuple after clamping
*/
public final void clampMax(int max) {
if (x > max)
x = max;
if (y > max)
y = max;
if (z > max)
z = max;
if (w > max)
w = max;
}
/**
* Sets each component of this tuple to its absolute value.
*/
public final void absolute() {
x = Math.abs(x);
y = Math.abs(y);
z = Math.abs(z);
w = Math.abs(w);
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public final int getX() {
return x;
}
/**
* Set the x coordinate.
*
* @param x value to x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(int x) {
this.x = x;
}
/**
* Get the y coordinate.
*
* @return the y coordinate.
*
* @since vecmath 1.5
*/
public final int getY() {
return y;
}
/**
* Set the y coordinate.
*
* @param y value to y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(int y) {
this.y = y;
}
/**
* Get the z coordinate.
*
* @return the z coordinate.
*
* @since vecmath 1.5
*/
public final int getZ() {
return z;
}
/**
* Set the z coordinate.
*
* @param z value to z coordinate.
*
* @since vecmath 1.5
*/
public final void setZ(int z) {
this.z = z;
}
/**
* Get the w coordinate.
* @return the w coordinate.
* @since vecmath 1.5
*/
public final int getW() {
return w;
}
/**
* Set the w coordinate.
*
* @param w value to w coordinate.
*
* @since vecmath 1.5
*/
public final void setW(int w) {
this.w = w;
}
}
source-cvs/vecmath/src/javax/vecmath/Quat4d.java 0000644 0001750 0001750 00000037553 10761613452 021230 0 ustar jonny jonny /*
* $RCSfile: Quat4d.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.7 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
/**
* A 4-element quaternion represented by double precision floating
* point x,y,z,w coordinates. The quaternion is always normalized.
*
*/
public class Quat4d extends Tuple4d implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = 7577479888820201099L;
// Fixed to issue 538
final static double EPS = 1.0e-12;
final static double EPS2 = 1.0e-30;
final static double PIO2 = 1.57079632679;
/**
* Constructs and initializes a Quat4d from the specified xyzw coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w scalar component
*/
public Quat4d(double x, double y, double z, double w)
{
double mag;
mag = 1.0/Math.sqrt( x*x + y*y + z*z + w*w );
this.x = x*mag;
this.y = y*mag;
this.z = z*mag;
this.w = w*mag;
}
/**
* Constructs and initializes a Quat4d from the array of length 4.
* @param q the array of length 4 containing xyzw in order
*/
public Quat4d(double[] q)
{
double mag;
mag = 1.0/Math.sqrt( q[0]*q[0] + q[1]*q[1] + q[2]*q[2] + q[3]*q[3] );
x = q[0]*mag;
y = q[1]*mag;
z = q[2]*mag;
w = q[3]*mag;
}
/**
* Constructs and initializes a Quat4d from the specified Quat4d.
* @param q1 the Quat4d containing the initialization x y z w data
*/
public Quat4d(Quat4d q1)
{
super(q1);
}
/**
* Constructs and initializes a Quat4d from the specified Quat4f.
* @param q1 the Quat4f containing the initialization x y z w data
*/
public Quat4d(Quat4f q1)
{
super(q1);
}
/**
* Constructs and initializes a Quat4d from the specified Tuple4f.
* @param t1 the Tuple4f containing the initialization x y z w data
*/
public Quat4d(Tuple4f t1)
{
double mag;
mag = 1.0/Math.sqrt( t1.x*t1.x + t1.y*t1.y + t1.z*t1.z + t1.w*t1.w );
x = t1.x*mag;
y = t1.y*mag;
z = t1.z*mag;
w = t1.w*mag;
}
/**
* Constructs and initializes a Quat4d from the specified Tuple4d.
* @param t1 the Tuple4d containing the initialization x y z w data
*/
public Quat4d(Tuple4d t1)
{
double mag;
mag = 1.0/Math.sqrt( t1.x*t1.x + t1.y*t1.y + t1.z*t1.z + t1.w*t1.w );
x = t1.x*mag;
y = t1.y*mag;
z = t1.z*mag;
w = t1.w*mag;
}
/**
* Constructs and initializes a Quat4d to (0,0,0,0).
*/
public Quat4d()
{
super();
}
/**
* Sets the value of this quaternion to the conjugate of quaternion q1.
* @param q1 the source vector
*/
public final void conjugate(Quat4d q1)
{
this.x = -q1.x;
this.y = -q1.y;
this.z = -q1.z;
this.w = q1.w;
}
/**
* Negate the value of of each of this quaternion's x,y,z coordinates
* in place.
*/
public final void conjugate()
{
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
}
/**
* Sets the value of this quaternion to the quaternion product of
* quaternions q1 and q2 (this = q1 * q2).
* Note that this is safe for aliasing (e.g. this can be q1 or q2).
* @param q1 the first quaternion
* @param q2 the second quaternion
*/
public final void mul(Quat4d q1, Quat4d q2)
{
if (this != q1 && this != q2) {
this.w = q1.w*q2.w - q1.x*q2.x - q1.y*q2.y - q1.z*q2.z;
this.x = q1.w*q2.x + q2.w*q1.x + q1.y*q2.z - q1.z*q2.y;
this.y = q1.w*q2.y + q2.w*q1.y - q1.x*q2.z + q1.z*q2.x;
this.z = q1.w*q2.z + q2.w*q1.z + q1.x*q2.y - q1.y*q2.x;
} else {
double x, y, w;
w = q1.w*q2.w - q1.x*q2.x - q1.y*q2.y - q1.z*q2.z;
x = q1.w*q2.x + q2.w*q1.x + q1.y*q2.z - q1.z*q2.y;
y = q1.w*q2.y + q2.w*q1.y - q1.x*q2.z + q1.z*q2.x;
this.z = q1.w*q2.z + q2.w*q1.z + q1.x*q2.y - q1.y*q2.x;
this.w = w;
this.x = x;
this.y = y;
}
}
/**
* Sets the value of this quaternion to the quaternion product of
* itself and q1 (this = this * q1).
* @param q1 the other quaternion
*/
public final void mul(Quat4d q1)
{
double x, y, w;
w = this.w*q1.w - this.x*q1.x - this.y*q1.y - this.z*q1.z;
x = this.w*q1.x + q1.w*this.x + this.y*q1.z - this.z*q1.y;
y = this.w*q1.y + q1.w*this.y - this.x*q1.z + this.z*q1.x;
this.z = this.w*q1.z + q1.w*this.z + this.x*q1.y - this.y*q1.x;
this.w = w;
this.x = x;
this.y = y;
}
/**
* Multiplies quaternion q1 by the inverse of quaternion q2 and places
* the value into this quaternion. The value of both argument quaternions
* is preservered (this = q1 * q2^-1).
* @param q1 the first quaternion
* @param q2 the second quaternion
*/
public final void mulInverse(Quat4d q1, Quat4d q2)
{
Quat4d tempQuat = new Quat4d(q2);
tempQuat.inverse();
this.mul(q1, tempQuat);
}
/**
* Multiplies this quaternion by the inverse of quaternion q1 and places
* the value into this quaternion. The value of the argument quaternion
* is preserved (this = this * q^-1).
* @param q1 the other quaternion
*/
public final void mulInverse(Quat4d q1)
{
Quat4d tempQuat = new Quat4d(q1);
tempQuat.inverse();
this.mul(tempQuat);
}
/**
* Sets the value of this quaternion to quaternion inverse of quaternion q1.
* @param q1 the quaternion to be inverted
*/
public final void inverse(Quat4d q1)
{
double norm;
norm = 1.0/(q1.w*q1.w + q1.x*q1.x + q1.y*q1.y + q1.z*q1.z);
this.w = norm*q1.w;
this.x = -norm*q1.x;
this.y = -norm*q1.y;
this.z = -norm*q1.z;
}
/**
* Sets the value of this quaternion to the quaternion inverse of itself.
*/
public final void inverse()
{
double norm;
norm = 1.0/(this.w*this.w + this.x*this.x + this.y*this.y + this.z*this.z);
this.w *= norm;
this.x *= -norm;
this.y *= -norm;
this.z *= -norm;
}
/**
* Sets the value of this quaternion to the normalized value
* of quaternion q1.
* @param q1 the quaternion to be normalized.
*/
public final void normalize(Quat4d q1)
{
double norm;
norm = (q1.x*q1.x + q1.y*q1.y + q1.z*q1.z + q1.w*q1.w);
if (norm > 0.0) {
norm = 1.0/Math.sqrt(norm);
this.x = norm*q1.x;
this.y = norm*q1.y;
this.z = norm*q1.z;
this.w = norm*q1.w;
} else {
this.x = 0.0;
this.y = 0.0;
this.z = 0.0;
this.w = 0.0;
}
}
/**
* Normalizes the value of this quaternion in place.
*/
public final void normalize()
{
double norm;
norm = (this.x*this.x + this.y*this.y + this.z*this.z + this.w*this.w);
if (norm > 0.0) {
norm = 1.0 / Math.sqrt(norm);
this.x *= norm;
this.y *= norm;
this.z *= norm;
this.w *= norm;
} else {
this.x = 0.0;
this.y = 0.0;
this.z = 0.0;
this.w = 0.0;
}
}
/**
* Sets the value of this quaternion to the rotational component of
* the passed matrix.
* @param m1 the matrix4f
*/
public final void set(Matrix4f m1)
{
double ww = 0.25*(m1.m00 + m1.m11 + m1.m22 + m1.m33);
if (ww >= 0) {
if (ww >= EPS2) {
this.w = Math.sqrt(ww);
ww = 0.25/this.w;
this.x = ((m1.m21 - m1.m12)*ww);
this.y = ((m1.m02 - m1.m20)*ww);
this.z = ((m1.m10 - m1.m01)*ww);
return;
}
} else {
this.w = 0;
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.w = 0;
ww = -0.5*(m1.m11 + m1.m22);
if (ww >= 0) {
if (ww >= EPS2) {
this.x = Math.sqrt(ww);
ww = 1.0/(2.0*this.x);
this.y = (m1.m10*ww);
this.z = (m1.m20*ww);
return;
}
} else {
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.x = 0;
ww = 0.5*(1.0 - m1.m22);
if (ww >= EPS2) {
this.y = Math.sqrt(ww);
this.z = (m1.m21)/(2.0*this.y);
return;
}
this.y = 0;
this.z = 1;
}
/**
* Sets the value of this quaternion to the rotational component of
* the passed matrix.
* @param m1 the matrix4d
*/
public final void set(Matrix4d m1)
{
double ww = 0.25*(m1.m00 + m1.m11 + m1.m22 + m1.m33);
if (ww >= 0) {
if (ww >= EPS2) {
this.w = Math.sqrt(ww);
ww = 0.25/this.w;
this.x = (m1.m21 - m1.m12)*ww;
this.y = (m1.m02 - m1.m20)*ww;
this.z = (m1.m10 - m1.m01)*ww;
return;
}
} else {
this.w = 0;
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.w = 0;
ww = -0.5*(m1.m11 + m1.m22);
if (ww >= 0) {
if (ww >= EPS2){
this.x = Math.sqrt(ww);
ww = 0.5/this.x;
this.y = m1.m10*ww;
this.z = m1.m20*ww;
return;
}
} else {
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.x = 0.0;
ww = 0.5*(1.0 - m1.m22);
if (ww >= EPS2) {
this.y = Math.sqrt(ww);
this.z = m1.m21/(2.0*this.y);
return;
}
this.y = 0;
this.z = 1;
}
/**
* Sets the value of this quaternion to the rotational component of
* the passed matrix.
* @param m1 the matrix3f
*/
public final void set(Matrix3f m1)
{
double ww = 0.25*(m1.m00 + m1.m11 + m1.m22 + 1.0);
if (ww >= 0) {
if (ww >= EPS2) {
this.w = Math.sqrt(ww);
ww = 0.25/this.w;
this.x = ((m1.m21 - m1.m12)*ww);
this.y = ((m1.m02 - m1.m20)*ww);
this.z = ((m1.m10 - m1.m01)*ww);
return;
}
} else {
this.w = 0;
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.w = 0;
ww = -0.5*(m1.m11 + m1.m22);
if (ww >= 0) {
if (ww >= EPS2) {
this.x = Math.sqrt(ww);
ww = 0.5/this.x;
this.y = (m1.m10*ww);
this.z = (m1.m20*ww);
return;
}
} else {
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.x = 0;
ww = 0.5*(1.0 - m1.m22);
if (ww >= EPS2) {
this.y = Math.sqrt(ww);
this.z = (m1.m21/(2.0*this.y));
}
this.y = 0;
this.z = 1;
}
/**
* Sets the value of this quaternion to the rotational component of
* the passed matrix.
* @param m1 the matrix3d
*/
public final void set(Matrix3d m1)
{
double ww = 0.25*(m1.m00 + m1.m11 + m1.m22 + 1.0);
if (ww >= 0) {
if (ww >= EPS2) {
this.w = Math.sqrt(ww);
ww = 0.25/this.w;
this.x = (m1.m21 - m1.m12)*ww;
this.y = (m1.m02 - m1.m20)*ww;
this.z = (m1.m10 - m1.m01)*ww;
return;
}
} else {
this.w = 0;
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.w = 0;
ww = -0.5*(m1.m11 + m1.m22);
if (ww >= 0) {
if (ww >= EPS2) {
this.x = Math.sqrt(ww);
ww = 0.5/this.x;
this.y = m1.m10*ww;
this.z = m1.m20*ww;
return;
}
} else {
this.x = 0;
this.y = 0;
this.z = 1;
return;
}
this.x = 0;
ww = 0.5*(1.0 - m1.m22);
if (ww >= EPS2) {
this.y = Math.sqrt(ww);
this.z = m1.m21/(2.0*this.y);
return;
}
this.y = 0;
this.z = 1;
}
/**
* Sets the value of this quaternion to the equivalent rotation
* of the AxisAngle argument.
* @param a the AxisAngle to be emulated
*/
public final void set(AxisAngle4f a)
{
double mag,amag;
// Quat = cos(theta/2) + sin(theta/2)(roation_axis)
amag = Math.sqrt( a.x*a.x + a.y*a.y + a.z*a.z);
if( amag < EPS ) {
w = 0.0;
x = 0.0;
y = 0.0;
z = 0.0;
} else {
mag = Math.sin(a.angle/2.0);
amag = 1.0/amag;
w = Math.cos(a.angle/2.0);
x = a.x*amag*mag;
y = a.y*amag*mag;
z = a.z*amag*mag;
}
}
/**
* Sets the value of this quaternion to the equivalent rotation
* of the AxisAngle argument.
* @param a the AxisAngle to be emulated
*/
public final void set(AxisAngle4d a)
{
double mag,amag;
// Quat = cos(theta/2) + sin(theta/2)(roation_axis)
amag = Math.sqrt( a.x*a.x + a.y*a.y + a.z*a.z);
if( amag < EPS ) {
w = 0.0;
x = 0.0;
y = 0.0;
z = 0.0;
} else {
amag = 1.0/amag;
mag = Math.sin(a.angle/2.0);
w = Math.cos(a.angle/2.0);
x = a.x*amag*mag;
y = a.y*amag*mag;
z = a.z*amag*mag;
}
}
/**
* Performs a great circle interpolation between this quaternion
* and the quaternion parameter and places the result into this
* quaternion.
* @param q1 the other quaternion
* @param alpha the alpha interpolation parameter
*/
public final void interpolate(Quat4d q1, double alpha) {
// From "Advanced Animation and Rendering Techniques"
// by Watt and Watt pg. 364, function as implemented appeared to be
// incorrect. Fails to choose the same quaternion for the double
// covering. Resulting in change of direction for rotations.
// Fixed function to negate the first quaternion in the case that the
// dot product of q1 and this is negative. Second case was not needed.
double dot,s1,s2,om,sinom;
dot = x*q1.x + y*q1.y + z*q1.z + w*q1.w;
if ( dot < 0 ) {
// negate quaternion
q1.x = -q1.x; q1.y = -q1.y; q1.z = -q1.z; q1.w = -q1.w;
dot = -dot;
}
if ( (1.0 - dot) > EPS ) {
om = Math.acos(dot);
sinom = Math.sin(om);
s1 = Math.sin((1.0-alpha)*om)/sinom;
s2 = Math.sin( alpha*om)/sinom;
} else{
s1 = 1.0 - alpha;
s2 = alpha;
}
w = s1*w + s2*q1.w;
x = s1*x + s2*q1.x;
y = s1*y + s2*q1.y;
z = s1*z + s2*q1.z;
}
/**
* Performs a great circle interpolation between quaternion q1
* and quaternion q2 and places the result into this quaternion.
* @param q1 the first quaternion
* @param q2 the second quaternion
* @param alpha the alpha interpolation parameter
*/
public final void interpolate(Quat4d q1, Quat4d q2, double alpha) {
// From "Advanced Animation and Rendering Techniques"
// by Watt and Watt pg. 364, function as implemented appeared to be
// incorrect. Fails to choose the same quaternion for the double
// covering. Resulting in change of direction for rotations.
// Fixed function to negate the first quaternion in the case that the
// dot product of q1 and this is negative. Second case was not needed.
double dot,s1,s2,om,sinom;
dot = q2.x*q1.x + q2.y*q1.y + q2.z*q1.z + q2.w*q1.w;
if ( dot < 0 ) {
// negate quaternion
q1.x = -q1.x; q1.y = -q1.y; q1.z = -q1.z; q1.w = -q1.w;
dot = -dot;
}
if ( (1.0 - dot) > EPS ) {
om = Math.acos(dot);
sinom = Math.sin(om);
s1 = Math.sin((1.0-alpha)*om)/sinom;
s2 = Math.sin( alpha*om)/sinom;
} else{
s1 = 1.0 - alpha;
s2 = alpha;
}
w = s1*q1.w + s2*q2.w;
x = s1*q1.x + s2*q2.x;
y = s1*q1.y + s2*q2.y;
z = s1*q1.z + s2*q2.z;
}
}
source-cvs/vecmath/src/javax/vecmath/TexCoord3f.java 0000644 0001750 0001750 00000005651 10761613452 022040 0 ustar jonny jonny /*
* $RCSfile: TexCoord3f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 3 element texture coordinate that is represented by single precision
* floating point x,y,z coordinates.
*
*/
public class TexCoord3f extends Tuple3f implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = -3517736544731446513L;
/**
* Constructs and initializes a TexCoord3f from the specified xyz
* coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public TexCoord3f(float x, float y, float z)
{
super(x,y,z);
}
/**
* Constructs and initializes a TexCoord3f from the array of length 3.
* @param v the array of length 3 containing xyz in order
*/
public TexCoord3f(float[] v)
{
super(v);
}
/**
* Constructs and initializes a TexCoord3f from the specified TexCoord3f.
* @param v1 the TexCoord3f containing the initialization x y z data
*/
public TexCoord3f(TexCoord3f v1)
{
super(v1);
}
/**
* Constructs and initializes a TexCoord3f from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public TexCoord3f(Tuple3f t1)
{
super(t1);
}
/**
* Constructs and initializes a TexCoord3f from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public TexCoord3f(Tuple3d t1)
{
super(t1);
}
/**
* Constructs and initializes a TexCoord3f to (0,0,0).
*/
public TexCoord3f()
{
super();
}
}
source-cvs/vecmath/src/javax/vecmath/Point2f.java 0000644 0001750 0001750 00000010255 10761613452 021375 0 ustar jonny jonny /*
* $RCSfile: Point2f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 2 element point that is represented by single precision floating
* point x,y coordinates.
*
*/
public class Point2f extends Tuple2f implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = -4801347926528714435L;
/**
* Constructs and initializes a Point2f from the specified xy coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public Point2f(float x, float y)
{
super(x,y);
}
/**
* Constructs and initializes a Point2f from the specified array.
* @param p the array of length 2 containing xy in order
*/
public Point2f(float[] p)
{
super(p);
}
/**
* Constructs and initializes a Point2f from the specified Point2f.
* @param p1 the Point2f containing the initialization x y data
*/
public Point2f(Point2f p1)
{
super(p1);
}
/**
* Constructs and initializes a Point2f from the specified Point2d.
* @param p1 the Point2d containing the initialization x y z data
*/
public Point2f(Point2d p1)
{
super(p1);
}
/**
* Constructs and initializes a Point2f from the specified Tuple2d.
* @param t1 the Tuple2d containing the initialization x y z data
*/
public Point2f(Tuple2d t1)
{
super(t1);
}
/**
* Constructs and initializes a Point2f from the specified Tuple2f.
* @param t1 the Tuple2f containing the initialization x y data
*/
public Point2f(Tuple2f t1)
{
super(t1);
}
/**
* Constructs and initializes a Point2f to (0,0).
*/
public Point2f()
{
super();
}
/**
* Computes the square of the distance between this point and point p1.
* @param p1 the other point
*/
public final float distanceSquared(Point2f p1)
{
float dx, dy;
dx = this.x-p1.x;
dy = this.y-p1.y;
return dx*dx+dy*dy;
}
/**
* Computes the distance between this point and point p1.
* @param p1 the other point
*/
public final float distance(Point2f p1)
{
float dx, dy;
dx = this.x-p1.x;
dy = this.y-p1.y;
return (float) Math.sqrt(dx*dx+dy*dy);
}
/**
* Computes the L-1 (Manhattan) distance between this point and
* point p1. The L-1 distance is equal to abs(x1-x2) + abs(y1-y2).
* @param p1 the other point
*/
public final float distanceL1(Point2f p1)
{
return( Math.abs(this.x-p1.x) + Math.abs(this.y-p1.y));
}
/**
* Computes the L-infinite distance between this point and
* point p1. The L-infinite distance is equal to
* MAX[abs(x1-x2), abs(y1-y2)].
* @param p1 the other point
*/
public final float distanceLinf(Point2f p1)
{
return(Math.max( Math.abs(this.x-p1.x), Math.abs(this.y-p1.y)));
}
}
source-cvs/vecmath/src/javax/vecmath/VecMathUtil.java 0000644 0001750 0001750 00000007726 10761613453 022253 0 ustar jonny jonny /*
* $RCSfile: VecMathUtil.java,v $
*
* Copyright 2004-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
/**
* Utility vecmath class used when computing the hash code for vecmath
* objects containing float or double values. This fixes Issue 36.
*/
class VecMathUtil {
/**
* Returns the representation of the specified floating-point
* value according to the IEEE 754 floating-point "single format"
* bit layout, after first mapping -0.0 to 0.0. This method is
* identical to Float.floatToIntBits(float) except that an integer
* value of 0 is returned for a floating-point value of
* -0.0f. This is done for the purpose of computing a hash code
* that satisfies the contract of hashCode() and equals(). The
* equals() method in each vecmath class does a pair-wise "=="
* test on each floating-point field in the class (e.g., x, y, and
* z for a Tuple3f). Since 0.0f == -0.0f returns true,
* we must also return the same hash code for two objects, one of
* which has a field with a value of -0.0f and the other of which
* has a cooresponding field with a value of 0.0f.
*
* @param f an input floating-point number
* @return the integer bits representing that floating-point
* number, after first mapping -0.0f to 0.0f
*/
static int floatToIntBits(float f) {
// Check for +0 or -0
if (f == 0.0f) {
return 0;
}
else {
return Float.floatToIntBits(f);
}
}
/**
* Returns the representation of the specified floating-point
* value according to the IEEE 754 floating-point "double format"
* bit layout, after first mapping -0.0 to 0.0. This method is
* identical to Double.doubleToLongBits(double) except that an
* integer value of 0L is returned for a floating-point value of
* -0.0. This is done for the purpose of computing a hash code
* that satisfies the contract of hashCode() and equals(). The
* equals() method in each vecmath class does a pair-wise "=="
* test on each floating-point field in the class (e.g., x, y, and
* z for a Tuple3d). Since 0.0 == -0.0 returns true, we
* must also return the same hash code for two objects, one of
* which has a field with a value of -0.0 and the other of which
* has a cooresponding field with a value of 0.0.
*
* @param d an input double precision floating-point number
* @return the integer bits representing that floating-point
* number, after first mapping -0.0f to 0.0f
*/
static long doubleToLongBits(double d) {
// Check for +0 or -0
if (d == 0.0) {
return 0L;
}
else {
return Double.doubleToLongBits(d);
}
}
/**
* Do not construct an instance of this class.
*/
private VecMathUtil() {
}
}
source-cvs/vecmath/src/javax/vecmath/Color3b.java 0000644 0001750 0001750 00000010457 10761613452 021363 0 ustar jonny jonny /*
* $RCSfile: Color3b.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.6 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.awt.Color;
/**
* A three-byte color value represented by byte x, y, and z values. The
* x, y, and z values represent the red, green, and blue values,
* respectively.
*
* Note that Java defines a byte as a signed integer in the range
* [-128, 127]. However, colors are more typically represented by values
* in the range [0, 255]. Java 3D recognizes this and for color
* treats the bytes as if the range were [0, 255]---in other words, as
* if the bytes were unsigned.
*
* Java 3D assumes that a linear (gamma-corrected) visual is used for
* all colors.
*
*/
public class Color3b extends Tuple3b implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = 6632576088353444794L;
/**
* Constructs and initializes a Color3b from the specified three values.
* @param c1 the red color value
* @param c2 the green color value
* @param c3 the blue color value
*/
public Color3b(byte c1, byte c2, byte c3) {
super(c1,c2,c3);
}
/**
* Constructs and initializes a Color3b from input array of length 3.
* @param c the array of length 3 containing the r,g,b data in order
*/
public Color3b(byte[] c) {
super(c);
}
/**
* Constructs and initializes a Color3b from the specified Color3b.
* @param c1 the Color3b containing the initialization r,g,b data
*/
public Color3b(Color3b c1) {
super(c1);
}
/**
* Constructs and initializes a Color3b from the specified Tuple3b.
* @param t1 the Tuple3b containing the initialization r,g,b data
*/
public Color3b(Tuple3b t1) {
super(t1);
}
/**
* Constructs and initializes a Color3b from the specified AWT
* Color object. The alpha value of the AWT color is ignored.
* No conversion is done on the color to compensate for
* gamma correction.
*
* @param color the AWT color with which to initialize this
* Color3b object
*
* @since vecmath 1.2
*/
public Color3b(Color color) {
super((byte)color.getRed(),
(byte)color.getGreen(),
(byte)color.getBlue());
}
/**
* Constructs and initializes a Color3b to (0,0,0).
*/
public Color3b() {
super();
}
/**
* Sets the r,g,b values of this Color3b object to those of the
* specified AWT Color object.
* No conversion is done on the color to compensate for
* gamma correction.
*
* @param color the AWT color to copy into this Color3b object
*
* @since vecmath 1.2
*/
public final void set(Color color) {
x = (byte)color.getRed();
y = (byte)color.getGreen();
z = (byte)color.getBlue();
}
/**
* Returns a new AWT color object initialized with the r,g,b
* values of this Color3b object.
*
* @return a new AWT Color object
*
* @since vecmath 1.2
*/
public final Color get() {
int r = (int)x & 0xff;
int g = (int)y & 0xff;
int b = (int)z & 0xff;
return new Color(r, g, b);
}
}
source-cvs/vecmath/src/javax/vecmath/Matrix4d.java 0000644 0001750 0001750 00000323232 10761613452 021552 0 ustar jonny jonny /*
* $RCSfile: Matrix4d.java,v $
*
* Copyright 1996-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.8 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A double precision floating point 4 by 4 matrix.
* Primarily to support 3D rotations.
*
*/
public class Matrix4d implements java.io.Serializable, Cloneable {
// Compatible with 1.1
static final long serialVersionUID = 8223903484171633710L;
/**
* The first element of the first row.
*/
public double m00;
/**
* The second element of the first row.
*/
public double m01;
/**
* The third element of the first row.
*/
public double m02;
/**
* The fourth element of the first row.
*/
public double m03;
/**
* The first element of the second row.
*/
public double m10;
/**
* The second element of the second row.
*/
public double m11;
/**
* The third element of the second row.
*/
public double m12;
/**
* The fourth element of the second row.
*/
public double m13;
/**
* The first element of the third row.
*/
public double m20;
/**
* The second element of the third row.
*/
public double m21;
/**
* The third element of the third row.
*/
public double m22;
/**
* The fourth element of the third row.
*/
public double m23;
/**
* The first element of the fourth row.
*/
public double m30;
/**
* The second element of the fourth row.
*/
public double m31;
/**
* The third element of the fourth row.
*/
public double m32;
/**
* The fourth element of the fourth row.
*/
public double m33;
/*
double[] tmp = new double[16];
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
*/
private static final double EPS = 1.0E-10;
/**
* Constructs and initializes a Matrix4d from the specified 16 values.
* @param m00 the [0][0] element
* @param m01 the [0][1] element
* @param m02 the [0][2] element
* @param m03 the [0][3] element
* @param m10 the [1][0] element
* @param m11 the [1][1] element
* @param m12 the [1][2] element
* @param m13 the [1][3] element
* @param m20 the [2][0] element
* @param m21 the [2][1] element
* @param m22 the [2][2] element
* @param m23 the [2][3] element
* @param m30 the [3][0] element
* @param m31 the [3][1] element
* @param m32 the [3][2] element
* @param m33 the [3][3] element
*/
public Matrix4d(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13,
double m20, double m21, double m22, double m23,
double m30, double m31, double m32, double m33)
{
this.m00 = m00;
this.m01 = m01;
this.m02 = m02;
this.m03 = m03;
this.m10 = m10;
this.m11 = m11;
this.m12 = m12;
this.m13 = m13;
this.m20 = m20;
this.m21 = m21;
this.m22 = m22;
this.m23 = m23;
this.m30 = m30;
this.m31 = m31;
this.m32 = m32;
this.m33 = m33;
}
/**
* Constructs and initializes a Matrix4d from the specified 16
* element array. this.m00 =v[0], this.m01=v[1], etc.
* @param v the array of length 16 containing in order
*/
public Matrix4d(double[] v)
{
this.m00 = v[ 0];
this.m01 = v[ 1];
this.m02 = v[ 2];
this.m03 = v[ 3];
this.m10 = v[ 4];
this.m11 = v[ 5];
this.m12 = v[ 6];
this.m13 = v[ 7];
this.m20 = v[ 8];
this.m21 = v[ 9];
this.m22 = v[10];
this.m23 = v[11];
this.m30 = v[12];
this.m31 = v[13];
this.m32 = v[14];
this.m33 = v[15];
}
/**
* Constructs and initializes a Matrix4d from the quaternion,
* translation, and scale values; the scale is applied only to the
* rotational components of the matrix (upper 3x3) and not to the
* translational components.
* @param q1 the quaternion value representing the rotational component
* @param t1 the translational component of the matrix
* @param s the scale value applied to the rotational components
*/
public Matrix4d(Quat4d q1, Vector3d t1, double s)
{
m00 = s*(1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
m10 = s*(2.0*(q1.x*q1.y + q1.w*q1.z));
m20 = s*(2.0*(q1.x*q1.z - q1.w*q1.y));
m01 = s*(2.0*(q1.x*q1.y - q1.w*q1.z));
m11 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
m21 = s*(2.0*(q1.y*q1.z + q1.w*q1.x));
m02 = s*(2.0*(q1.x*q1.z + q1.w*q1.y));
m12 = s*(2.0*(q1.y*q1.z - q1.w*q1.x));
m22 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
m03 = t1.x;
m13 = t1.y;
m23 = t1.z;
m30 = 0.0;
m31 = 0.0;
m32 = 0.0;
m33 = 1.0;
}
/**
* Constructs and initializes a Matrix4d from the quaternion,
* translation, and scale values; the scale is applied only to the
* rotational components of the matrix (upper 3x3) and not to the
* translational components.
* @param q1 the quaternion value representing the rotational component
* @param t1 the translational component of the matrix
* @param s the scale value applied to the rotational components
*/
public Matrix4d(Quat4f q1, Vector3d t1, double s)
{
m00 = s*(1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
m10 = s*(2.0*(q1.x*q1.y + q1.w*q1.z));
m20 = s*(2.0*(q1.x*q1.z - q1.w*q1.y));
m01 = s*(2.0*(q1.x*q1.y - q1.w*q1.z));
m11 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
m21 = s*(2.0*(q1.y*q1.z + q1.w*q1.x));
m02 = s*(2.0*(q1.x*q1.z + q1.w*q1.y));
m12 = s*(2.0*(q1.y*q1.z - q1.w*q1.x));
m22 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
m03 = t1.x;
m13 = t1.y;
m23 = t1.z;
m30 = 0.0;
m31 = 0.0;
m32 = 0.0;
m33 = 1.0;
}
/**
* Constructs a new matrix with the same values as the
* Matrix4d parameter.
* @param m1 the source matrix
*/
public Matrix4d(Matrix4d m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m03 = m1.m03;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m13 = m1.m13;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
this.m23 = m1.m23;
this.m30 = m1.m30;
this.m31 = m1.m31;
this.m32 = m1.m32;
this.m33 = m1.m33;
}
/**
* Constructs a new matrix with the same values as the
* Matrix4f parameter.
* @param m1 the source matrix
*/
public Matrix4d(Matrix4f m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m03 = m1.m03;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m13 = m1.m13;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
this.m23 = m1.m23;
this.m30 = m1.m30;
this.m31 = m1.m31;
this.m32 = m1.m32;
this.m33 = m1.m33;
}
/**
* Constructs and initializes a Matrix4d from the rotation matrix,
* translation, and scale values; the scale is applied only to the
* rotational components of the matrix (upper 3x3) and not to the
* translational components of the matrix.
* @param m1 the rotation matrix representing the rotational components
* @param t1 the translational components of the matrix
* @param s the scale value applied to the rotational components
*/
public Matrix4d(Matrix3f m1, Vector3d t1, double s)
{
this.m00 = m1.m00*s;
this.m01 = m1.m01*s;
this.m02 = m1.m02*s;
this.m03 = t1.x;
this.m10 = m1.m10*s;
this.m11 = m1.m11*s;
this.m12 = m1.m12*s;
this.m13 = t1.y;
this.m20 = m1.m20*s;
this.m21 = m1.m21*s;
this.m22 = m1.m22*s;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Constructs and initializes a Matrix4f from the rotation matrix,
* translation, and scale values; the scale is applied only to the
* rotational components of the matrix (upper 3x3) and not to the
* translational components of the matrix.
* @param m1 the rotation matrix representing the rotational components
* @param t1 the translational components of the matrix
* @param s the scale value applied to the rotational components
*/
public Matrix4d(Matrix3d m1, Vector3d t1, double s)
{
this.m00 = m1.m00*s;
this.m01 = m1.m01*s;
this.m02 = m1.m02*s;
this.m03 = t1.x;
this.m10 = m1.m10*s;
this.m11 = m1.m11*s;
this.m12 = m1.m12*s;
this.m13 = t1.y;
this.m20 = m1.m20*s;
this.m21 = m1.m21*s;
this.m22 = m1.m22*s;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Constructs and initializes a Matrix4d to all zeros.
*/
public Matrix4d()
{
this.m00 = 0.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = 0.0;
this.m10 = 0.0;
this.m11 = 0.0;
this.m12 = 0.0;
this.m13 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 0.0;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 0.0;
}
/**
* Returns a string that contains the values of this Matrix4d.
* @return the String representation
*/
public String toString() {
return
this.m00 + ", " + this.m01 + ", " + this.m02 + ", " + this.m03 + "\n" +
this.m10 + ", " + this.m11 + ", " + this.m12 + ", " + this.m13 + "\n" +
this.m20 + ", " + this.m21 + ", " + this.m22 + ", " + this.m23 + "\n" +
this.m30 + ", " + this.m31 + ", " + this.m32 + ", " + this.m33 + "\n";
}
/**
* Sets this Matrix4d to identity.
*/
public final void setIdentity()
{
this.m00 = 1.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = 0.0;
this.m10 = 0.0;
this.m11 = 1.0;
this.m12 = 0.0;
this.m13 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 1.0;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the specified element of this matrix4f to the value provided.
* @param row the row number to be modified (zero indexed)
* @param column the column number to be modified (zero indexed)
* @param value the new value
*/
public final void setElement(int row, int column, double value)
{
switch (row)
{
case 0:
switch(column)
{
case 0:
this.m00 = value;
break;
case 1:
this.m01 = value;
break;
case 2:
this.m02 = value;
break;
case 3:
this.m03 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d0"));
}
break;
case 1:
switch(column)
{
case 0:
this.m10 = value;
break;
case 1:
this.m11 = value;
break;
case 2:
this.m12 = value;
break;
case 3:
this.m13 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d0"));
}
break;
case 2:
switch(column)
{
case 0:
this.m20 = value;
break;
case 1:
this.m21 = value;
break;
case 2:
this.m22 = value;
break;
case 3:
this.m23 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d0"));
}
break;
case 3:
switch(column)
{
case 0:
this.m30 = value;
break;
case 1:
this.m31 = value;
break;
case 2:
this.m32 = value;
break;
case 3:
this.m33 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d0"));
}
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d0"));
}
}
/**
* Retrieves the value at the specified row and column of this matrix.
* @param row the row number to be retrieved (zero indexed)
* @param column the column number to be retrieved (zero indexed)
* @return the value at the indexed element
*/
public final double getElement(int row, int column)
{
switch (row)
{
case 0:
switch(column)
{
case 0:
return(this.m00);
case 1:
return(this.m01);
case 2:
return(this.m02);
case 3:
return(this.m03);
default:
break;
}
break;
case 1:
switch(column)
{
case 0:
return(this.m10);
case 1:
return(this.m11);
case 2:
return(this.m12);
case 3:
return(this.m13);
default:
break;
}
break;
case 2:
switch(column)
{
case 0:
return(this.m20);
case 1:
return(this.m21);
case 2:
return(this.m22);
case 3:
return(this.m23);
default:
break;
}
break;
case 3:
switch(column)
{
case 0:
return(this.m30);
case 1:
return(this.m31);
case 2:
return(this.m32);
case 3:
return(this.m33);
default:
break;
}
break;
default:
break;
}
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d1"));
}
/**
* Copies the matrix values in the specified row into the vector parameter.
* @param row the matrix row
* @param v the vector into which the matrix row values will be copied
*/
public final void getRow(int row, Vector4d v) {
if( row == 0 ) {
v.x = m00;
v.y = m01;
v.z = m02;
v.w = m03;
} else if(row == 1) {
v.x = m10;
v.y = m11;
v.z = m12;
v.w = m13;
} else if(row == 2) {
v.x = m20;
v.y = m21;
v.z = m22;
v.w = m23;
} else if(row == 3) {
v.x = m30;
v.y = m31;
v.z = m32;
v.w = m33;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d2"));
}
}
/**
* Copies the matrix values in the specified row into the array parameter.
* @param row the matrix row
* @param v the array into which the matrix row values will be copied
*/
public final void getRow(int row, double v[]) {
if( row == 0 ) {
v[0] = m00;
v[1] = m01;
v[2] = m02;
v[3] = m03;
} else if(row == 1) {
v[0] = m10;
v[1] = m11;
v[2] = m12;
v[3] = m13;
} else if(row == 2) {
v[0] = m20;
v[1] = m21;
v[2] = m22;
v[3] = m23;
} else if(row == 3) {
v[0] = m30;
v[1] = m31;
v[2] = m32;
v[3] = m33;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d2"));
}
}
/**
* Copies the matrix values in the specified column into the vector
* parameter.
* @param column the matrix column
* @param v the vector into which the matrix column values will be copied
*/
public final void getColumn(int column, Vector4d v) {
if( column == 0 ) {
v.x = m00;
v.y = m10;
v.z = m20;
v.w = m30;
} else if(column == 1) {
v.x = m01;
v.y = m11;
v.z = m21;
v.w = m31;
} else if(column == 2) {
v.x = m02;
v.y = m12;
v.z = m22;
v.w = m32;
} else if(column == 3) {
v.x = m03;
v.y = m13;
v.z = m23;
v.w = m33;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d3"));
}
}
/**
* Copies the matrix values in the specified column into the array
* parameter.
* @param column the matrix column
* @param v the array into which the matrix column values will be copied
*/
public final void getColumn(int column, double v[]) {
if( column == 0 ) {
v[0] = m00;
v[1] = m10;
v[2] = m20;
v[3] = m30;
} else if(column == 1) {
v[0] = m01;
v[1] = m11;
v[2] = m21;
v[3] = m31;
} else if(column == 2) {
v[0] = m02;
v[1] = m12;
v[2] = m22;
v[3] = m32;
} else if(column == 3) {
v[0] = m03;
v[1] = m13;
v[2] = m23;
v[3] = m33;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d3"));
}
}
/**
* Performs an SVD normalization of this matrix in order to acquire
* the normalized rotational component; the values are placed into
* the Matrix3d parameter.
* @param m1 the matrix into which the rotational component is placed
*/
public final void get(Matrix3d m1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m1.m00 = tmp_rot[0];
m1.m01 = tmp_rot[1];
m1.m02 = tmp_rot[2];
m1.m10 = tmp_rot[3];
m1.m11 = tmp_rot[4];
m1.m12 = tmp_rot[5];
m1.m20 = tmp_rot[6];
m1.m21 = tmp_rot[7];
m1.m22 = tmp_rot[8];
}
/**
* Performs an SVD normalization of this matrix in order to acquire
* the normalized rotational component; the values are placed into
* the Matrix3f parameter.
* @param m1 the matrix into which the rotational component is placed
*/
public final void get(Matrix3f m1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m1.m00 = (float)tmp_rot[0];
m1.m01 = (float)tmp_rot[1];
m1.m02 = (float)tmp_rot[2];
m1.m10 = (float)tmp_rot[3];
m1.m11 = (float)tmp_rot[4];
m1.m12 = (float)tmp_rot[5];
m1.m20 = (float)tmp_rot[6];
m1.m21 = (float)tmp_rot[7];
m1.m22 = (float)tmp_rot[8];
}
/**
* Performs an SVD normalization of this matrix to calculate
* the rotation as a 3x3 matrix, the translation, and the scale.
* None of the matrix values are modified.
* @param m1 the normalized matrix representing the rotation
* @param t1 the translation component
* @return the scale component of this transform
*/
public final double get(Matrix3d m1, Vector3d t1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m1.m00 = tmp_rot[0];
m1.m01 = tmp_rot[1];
m1.m02 = tmp_rot[2];
m1.m10 = tmp_rot[3];
m1.m11 = tmp_rot[4];
m1.m12 = tmp_rot[5];
m1.m20 = tmp_rot[6];
m1.m21 = tmp_rot[7];
m1.m22 = tmp_rot[8];
t1.x = m03;
t1.y = m13;
t1.z = m23;
return( Matrix3d.max3( tmp_scale ));
}
/**
* Performs an SVD normalization of this matrix to calculate
* the rotation as a 3x3 matrix, the translation, and the scale.
* None of the matrix values are modified.
* @param m1 the normalized matrix representing the rotation
* @param t1 the translation component
* @return the scale component of this transform
*/
public final double get(Matrix3f m1, Vector3d t1){
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m1.m00 = (float)tmp_rot[0];
m1.m01 = (float)tmp_rot[1];
m1.m02 = (float)tmp_rot[2];
m1.m10 = (float)tmp_rot[3];
m1.m11 = (float)tmp_rot[4];
m1.m12 = (float)tmp_rot[5];
m1.m20 = (float)tmp_rot[6];
m1.m21 = (float)tmp_rot[7];
m1.m22 = (float)tmp_rot[8];
t1.x = m03;
t1.y = m13;
t1.z = m23;
return( Matrix3d.max3( tmp_scale ));
}
/**
* Performs an SVD normalization of this matrix in order to acquire
* the normalized rotational component; the values are placed into
* the Quat4f parameter.
* @param q1 quaternion into which the rotation component is placed
*/
public final void get(Quat4f q1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
double ww;
ww = 0.25*(1.0 + tmp_rot[0] + tmp_rot[4] + tmp_rot[8]);
if(!((ww<0?-ww:ww) < 1.0e-30)) {
q1.w = (float)Math.sqrt(ww);
ww = 0.25/q1.w;
q1.x = (float)((tmp_rot[7] - tmp_rot[5])*ww);
q1.y = (float)((tmp_rot[2] - tmp_rot[6])*ww);
q1.z = (float)((tmp_rot[3] - tmp_rot[1])*ww);
return;
}
q1.w = 0.0f;
ww = -0.5*(tmp_rot[4] + tmp_rot[8]);
if(!((ww<0?-ww:ww) < 1.0e-30)) {
q1.x = (float)Math.sqrt(ww);
ww = 0.5/q1.x;
q1.y = (float)(tmp_rot[3]*ww);
q1.z = (float)(tmp_rot[6]*ww);
return;
}
q1.x = 0.0f;
ww = 0.5*(1.0 - tmp_rot[8]);
if(!((ww<0?-ww:ww) < 1.0e-30)) {
q1.y = (float)(Math.sqrt(ww));
q1.z = (float)(tmp_rot[7]/(2.0*q1.y));
return;
}
q1.y = 0.0f;
q1.z = 1.0f;
}
/**
* Performs an SVD normalization of q1 matrix in order to acquire
* the normalized rotational component; the values are placed into
* the Quat4d parameter.
* @param q1 the quaternion into which the rotation component is placed
*/
public final void get(Quat4d q1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
double ww;
ww = 0.25*(1.0 + tmp_rot[0] + tmp_rot[4] + tmp_rot[8]);
if(!((ww<0?-ww:ww) < 1.0e-30)) {
q1.w = Math.sqrt(ww);
ww = 0.25/q1.w;
q1.x = (tmp_rot[7] - tmp_rot[5])*ww;
q1.y = (tmp_rot[2] - tmp_rot[6])*ww;
q1.z = (tmp_rot[3] - tmp_rot[1])*ww;
return;
}
q1.w = 0.0f;
ww = -0.5*(tmp_rot[4] + tmp_rot[8]);
if(!((ww<0?-ww:ww) < 1.0e-30)) {
q1.x = Math.sqrt(ww);
ww = 0.5/q1.x;
q1.y = tmp_rot[3]*ww;
q1.z = tmp_rot[6]*ww;
return;
}
q1.x = 0.0;
ww = 0.5*(1.0 - tmp_rot[8]);
if(!((ww<0?-ww:ww) < 1.0e-30)) {
q1.y = Math.sqrt(ww);
q1.z = tmp_rot[7]/(2.0*q1.y);
return;
}
q1.y = 0.0;
q1.z = 1.0;
}
/**
* Retrieves the translational components of this matrix.
* @param trans the vector that will receive the translational component
*/
public final void get(Vector3d trans)
{
trans.x = m03;
trans.y = m13;
trans.z = m23;
}
/**
* Gets the upper 3x3 values of this matrix and places them into
* the matrix m1.
* @param m1 the matrix that will hold the values
*/
public final void getRotationScale(Matrix3f m1)
{
m1.m00 = (float)m00; m1.m01 = (float)m01; m1.m02 = (float)m02;
m1.m10 = (float)m10; m1.m11 = (float)m11; m1.m12 = (float)m12;
m1.m20 = (float)m20; m1.m21 = (float)m21; m1.m22 = (float)m22;
}
/**
* Gets the upper 3x3 values of this matrix and places them into
* the matrix m1.
* @param m1 the matrix that will hold the values
*/
public final void getRotationScale(Matrix3d m1)
{
m1.m00 = m00; m1.m01 = m01; m1.m02 = m02;
m1.m10 = m10; m1.m11 = m11; m1.m12 = m12;
m1.m20 = m20; m1.m21 = m21; m1.m22 = m22;
}
/**
* Performs an SVD normalization of this 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 will
* be returned. This matrix is not modified.
* @return the scale factor of this matrix
*/
public final double getScale()
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
return( Matrix3d.max3( tmp_scale ));
}
/**
* Replaces the upper 3x3 matrix values of this matrix with the
* values in the matrix m1.
* @param m1 the matrix that will be the new upper 3x3
*/
public final void setRotationScale(Matrix3d m1)
{
m00 = m1.m00; m01 = m1.m01; m02 = m1.m02;
m10 = m1.m10; m11 = m1.m11; m12 = m1.m12;
m20 = m1.m20; m21 = m1.m21; m22 = m1.m22;
}
/**
* Replaces the upper 3x3 matrix values of this matrix with the
* values in the matrix m1.
* @param m1 the matrix that will be the new upper 3x3
*/
public final void setRotationScale(Matrix3f m1)
{
m00 = m1.m00; m01 = m1.m01; m02 = m1.m02;
m10 = m1.m10; m11 = m1.m11; m12 = m1.m12;
m20 = m1.m20; m21 = m1.m21; m22 = m1.m22;
}
/**
* Sets the scale component of the current matrix by factoring
* out the current scale (by doing an SVD) from the rotational
* component and multiplying by the new scale.
* @param scale the new scale amount
*/
public final void setScale(double scale)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m00 = tmp_rot[0]*scale;
m01 = tmp_rot[1]*scale;
m02 = tmp_rot[2]*scale;
m10 = tmp_rot[3]*scale;
m11 = tmp_rot[4]*scale;
m12 = tmp_rot[5]*scale;
m20 = tmp_rot[6]*scale;
m21 = tmp_rot[7]*scale;
m22 = tmp_rot[8]*scale;
}
/**
* Sets the specified row of this matrix4d to the four values provided.
* @param row the row number to be modified (zero indexed)
* @param x the first column element
* @param y the second column element
* @param z the third column element
* @param w the fourth column element
*/
public final void setRow(int row, double x, double y, double z, double w)
{
switch (row) {
case 0:
this.m00 = x;
this.m01 = y;
this.m02 = z;
this.m03 = w;
break;
case 1:
this.m10 = x;
this.m11 = y;
this.m12 = z;
this.m13 = w;
break;
case 2:
this.m20 = x;
this.m21 = y;
this.m22 = z;
this.m23 = w;
break;
case 3:
this.m30 = x;
this.m31 = y;
this.m32 = z;
this.m33 = w;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d4"));
}
}
/**
* Sets the specified row of this matrix4d to the Vector provided.
* @param row the row number to be modified (zero indexed)
* @param v the replacement row
*/
public final void setRow(int row, Vector4d v)
{
switch (row) {
case 0:
this.m00 = v.x;
this.m01 = v.y;
this.m02 = v.z;
this.m03 = v.w;
break;
case 1:
this.m10 = v.x;
this.m11 = v.y;
this.m12 = v.z;
this.m13 = v.w;
break;
case 2:
this.m20 = v.x;
this.m21 = v.y;
this.m22 = v.z;
this.m23 = v.w;
break;
case 3:
this.m30 = v.x;
this.m31 = v.y;
this.m32 = v.z;
this.m33 = v.w;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d4"));
}
}
/**
* Sets the specified row of this matrix4d to the four values provided.
* @param row the row number to be modified (zero indexed)
* @param v the replacement row
*/
public final void setRow(int row, double v[])
{
switch (row) {
case 0:
this.m00 = v[0];
this.m01 = v[1];
this.m02 = v[2];
this.m03 = v[3];
break;
case 1:
this.m10 = v[0];
this.m11 = v[1];
this.m12 = v[2];
this.m13 = v[3];
break;
case 2:
this.m20 = v[0];
this.m21 = v[1];
this.m22 = v[2];
this.m23 = v[3];
break;
case 3:
this.m30 = v[0];
this.m31 = v[1];
this.m32 = v[2];
this.m33 = v[3];
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d4"));
}
}
/**
* Sets the specified column of this matrix4d to the four values provided.
* @param column the column number to be modified (zero indexed)
* @param x the first row element
* @param y the second row element
* @param z the third row element
* @param w the fourth row element
*/
public final void setColumn(int column, double x, double y, double z, double w)
{
switch (column) {
case 0:
this.m00 = x;
this.m10 = y;
this.m20 = z;
this.m30 = w;
break;
case 1:
this.m01 = x;
this.m11 = y;
this.m21 = z;
this.m31 = w;
break;
case 2:
this.m02 = x;
this.m12 = y;
this.m22 = z;
this.m32 = w;
break;
case 3:
this.m03 = x;
this.m13 = y;
this.m23 = z;
this.m33 = w;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d7"));
}
}
/**
* Sets the specified column of this matrix4d to the vector provided.
* @param column the column number to be modified (zero indexed)
* @param v the replacement column
*/
public final void setColumn(int column, Vector4d v)
{
switch (column) {
case 0:
this.m00 = v.x;
this.m10 = v.y;
this.m20 = v.z;
this.m30 = v.w;
break;
case 1:
this.m01 = v.x;
this.m11 = v.y;
this.m21 = v.z;
this.m31 = v.w;
break;
case 2:
this.m02 = v.x;
this.m12 = v.y;
this.m22 = v.z;
this.m32 = v.w;
break;
case 3:
this.m03 = v.x;
this.m13 = v.y;
this.m23 = v.z;
this.m33 = v.w;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d7"));
}
}
/**
* Sets the specified column of this matrix4d to the four values provided.
* @param column the column number to be modified (zero indexed)
* @param v the replacement column
*/
public final void setColumn(int column, double v[])
{
switch (column) {
case 0:
this.m00 = v[0];
this.m10 = v[1];
this.m20 = v[2];
this.m30 = v[3];
break;
case 1:
this.m01 = v[0];
this.m11 = v[1];
this.m21 = v[2];
this.m31 = v[3];
break;
case 2:
this.m02 = v[0];
this.m12 = v[1];
this.m22 = v[2];
this.m32 = v[3];
break;
case 3:
this.m03 = v[0];
this.m13 = v[1];
this.m23 = v[2];
this.m33 = v[3];
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix4d7"));
}
}
/**
* Adds a scalar to each component of this matrix.
* @param scalar the scalar adder
*/
public final void add(double scalar)
{
m00 += scalar;
m01 += scalar;
m02 += scalar;
m03 += scalar;
m10 += scalar;
m11 += scalar;
m12 += scalar;
m13 += scalar;
m20 += scalar;
m21 += scalar;
m22 += scalar;
m23 += scalar;
m30 += scalar;
m31 += scalar;
m32 += scalar;
m33 += scalar;
}
/**
* Adds a scalar to each component of the matrix m1 and places
* the result into this. Matrix m1 is not modified.
* @param scalar the scalar adder
* @param m1 the original matrix values
*/
public final void add(double scalar, Matrix4d m1)
{
this.m00 = m1.m00 + scalar;
this.m01 = m1.m01 + scalar;
this.m02 = m1.m02 + scalar;
this.m03 = m1.m03 + scalar;
this.m10 = m1.m10 + scalar;
this.m11 = m1.m11 + scalar;
this.m12 = m1.m12 + scalar;
this.m13 = m1.m13 + scalar;
this.m20 = m1.m20 + scalar;
this.m21 = m1.m21 + scalar;
this.m22 = m1.m22 + scalar;
this.m23 = m1.m23 + scalar;
this.m30 = m1.m30 + scalar;
this.m31 = m1.m31 + scalar;
this.m32 = m1.m32 + scalar;
this.m33 = m1.m33 + scalar;
}
/**
* Sets the value of this matrix to the matrix sum of matrices m1 and m2.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void add(Matrix4d m1, Matrix4d m2)
{
this.m00 = m1.m00 + m2.m00;
this.m01 = m1.m01 + m2.m01;
this.m02 = m1.m02 + m2.m02;
this.m03 = m1.m03 + m2.m03;
this.m10 = m1.m10 + m2.m10;
this.m11 = m1.m11 + m2.m11;
this.m12 = m1.m12 + m2.m12;
this.m13 = m1.m13 + m2.m13;
this.m20 = m1.m20 + m2.m20;
this.m21 = m1.m21 + m2.m21;
this.m22 = m1.m22 + m2.m22;
this.m23 = m1.m23 + m2.m23;
this.m30 = m1.m30 + m2.m30;
this.m31 = m1.m31 + m2.m31;
this.m32 = m1.m32 + m2.m32;
this.m33 = m1.m33 + m2.m33;
}
/**
* Sets the value of this matrix to sum of itself and matrix m1.
* @param m1 the other matrix
*/
public final void add(Matrix4d m1)
{
this.m00 += m1.m00;
this.m01 += m1.m01;
this.m02 += m1.m02;
this.m03 += m1.m03;
this.m10 += m1.m10;
this.m11 += m1.m11;
this.m12 += m1.m12;
this.m13 += m1.m13;
this.m20 += m1.m20;
this.m21 += m1.m21;
this.m22 += m1.m22;
this.m23 += m1.m23;
this.m30 += m1.m30;
this.m31 += m1.m31;
this.m32 += m1.m32;
this.m33 += m1.m33;
}
/**
* Sets the value of this matrix to the matrix difference
* of matrices m1 and m2.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void sub(Matrix4d m1, Matrix4d m2)
{
this.m00 = m1.m00 - m2.m00;
this.m01 = m1.m01 - m2.m01;
this.m02 = m1.m02 - m2.m02;
this.m03 = m1.m03 - m2.m03;
this.m10 = m1.m10 - m2.m10;
this.m11 = m1.m11 - m2.m11;
this.m12 = m1.m12 - m2.m12;
this.m13 = m1.m13 - m2.m13;
this.m20 = m1.m20 - m2.m20;
this.m21 = m1.m21 - m2.m21;
this.m22 = m1.m22 - m2.m22;
this.m23 = m1.m23 - m2.m23;
this.m30 = m1.m30 - m2.m30;
this.m31 = m1.m31 - m2.m31;
this.m32 = m1.m32 - m2.m32;
this.m33 = m1.m33 - m2.m33;
}
/**
* Sets the value of this matrix to the matrix difference of itself
* and matrix m1 (this = this - m1).
* @param m1 the other matrix
*/
public final void sub(Matrix4d m1)
{
this.m00 -= m1.m00;
this.m01 -= m1.m01;
this.m02 -= m1.m02;
this.m03 -= m1.m03;
this.m10 -= m1.m10;
this.m11 -= m1.m11;
this.m12 -= m1.m12;
this.m13 -= m1.m13;
this.m20 -= m1.m20;
this.m21 -= m1.m21;
this.m22 -= m1.m22;
this.m23 -= m1.m23;
this.m30 -= m1.m30;
this.m31 -= m1.m31;
this.m32 -= m1.m32;
this.m33 -= m1.m33;
}
/**
* Sets the value of this matrix to its transpose.
*/
public final void transpose()
{
double temp;
temp = this.m10;
this.m10 = this.m01;
this.m01 = temp;
temp = this.m20;
this.m20 = this.m02;
this.m02 = temp;
temp = this.m30;
this.m30 = this.m03;
this.m03 = temp;
temp = this.m21;
this.m21 = this.m12;
this.m12 = temp;
temp = this.m31;
this.m31 = this.m13;
this.m13 = temp;
temp = this.m32;
this.m32 = this.m23;
this.m23 = temp;
}
/**
* Sets the value of this matrix to the transpose of the argument matrix
* @param m1 the matrix to be transposed
*/
public final void transpose(Matrix4d m1)
{
if (this != m1) {
this.m00 = m1.m00;
this.m01 = m1.m10;
this.m02 = m1.m20;
this.m03 = m1.m30;
this.m10 = m1.m01;
this.m11 = m1.m11;
this.m12 = m1.m21;
this.m13 = m1.m31;
this.m20 = m1.m02;
this.m21 = m1.m12;
this.m22 = m1.m22;
this.m23 = m1.m32;
this.m30 = m1.m03;
this.m31 = m1.m13;
this.m32 = m1.m23;
this.m33 = m1.m33;
} else
this.transpose();
}
/**
* Sets the values in this Matrix4d equal to the row-major
* array parameter (ie, the first four elements of the
* array will be copied into the first row of this matrix, etc.).
* @param m the double precision array of length 16
*/
public final void set(double[] m)
{
m00 = m[0];
m01 = m[1];
m02 = m[2];
m03 = m[3];
m10 = m[4];
m11 = m[5];
m12 = m[6];
m13 = m[7];
m20 = m[8];
m21 = m[9];
m22 = m[10];
m23 = m[11];
m30 = m[12];
m31 = m[13];
m32 = m[14];
m33 = m[15];
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix values in the single precision Matrix3f argument; the other
* elements of this matrix are initialized as if this were an identity
* matrix (i.e., affine matrix with no translational component).
* @param m1 the double precision 3x3 matrix
*/
public final void set(Matrix3f m1)
{
m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; m03 = 0.0;
m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; m13 = 0.0;
m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; m23 = 0.0;
m30 = 0.0; m31 = 0.0 ; m32 = 0.0 ; m33 = 1.0;
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix values in the double precision Matrix3d argument; the other
* elements of this matrix are initialized as if this were an identity
* matrix (i.e., affine matrix with no translational component).
* @param m1 the double precision 3x3 matrix
*/
public final void set(Matrix3d m1)
{
m00 = m1.m00; m01 = m1.m01; m02 = m1.m02; m03 = 0.0;
m10 = m1.m10; m11 = m1.m11; m12 = m1.m12; m13 = 0.0;
m20 = m1.m20; m21 = m1.m21; m22 = m1.m22; m23 = 0.0;
m30 = 0.0; m31 = 0.0 ; m32 = 0.0 ; m33 = 1.0;
}
/**
* Sets the value of this matrix to the matrix conversion of the
* (double precision) quaternion argument.
* @param q1 the quaternion to be converted
*/
public final void set(Quat4d q1)
{
this.m00 = (1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = (2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = (2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = (2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = (2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = (2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = (2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
this.m03 = 0.0;
this.m13 = 0.0;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix to the matrix conversion of the
* double precision axis and angle argument.
* @param a1 the axis and angle to be converted
*/
public final void set(AxisAngle4d a1)
{
double mag = Math.sqrt( a1.x*a1.x + a1.y*a1.y + a1.z*a1.z);
if( mag < EPS ) {
m00 = 1.0;
m01 = 0.0;
m02 = 0.0;
m10 = 0.0;
m11 = 1.0;
m12 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 1.0;
} else {
mag = 1.0/mag;
double ax = a1.x*mag;
double ay = a1.y*mag;
double az = a1.z*mag;
double sinTheta = Math.sin(a1.angle);
double cosTheta = Math.cos(a1.angle);
double t = 1.0 - cosTheta;
double xz = ax * az;
double xy = ax * ay;
double yz = ay * az;
m00 = t * ax * ax + cosTheta;
m01 = t * xy - sinTheta * az;
m02 = t * xz + sinTheta * ay;
m10 = t * xy + sinTheta * az;
m11 = t * ay * ay + cosTheta;
m12 = t * yz - sinTheta * ax;
m20 = t * xz - sinTheta * ay;
m21 = t * yz + sinTheta * ax;
m22 = t * az * az + cosTheta;
}
m03 = 0.0;
m13 = 0.0;
m23 = 0.0;
m30 = 0.0;
m31 = 0.0;
m32 = 0.0;
m33 = 1.0;
}
/**
* Sets the value of this matrix to the matrix conversion of the
* single precision quaternion argument.
* @param q1 the quaternion to be converted
*/
public final void set(Quat4f q1)
{
this.m00 = (1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = (2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = (2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = (2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = (2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = (2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = (2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
this.m03 = 0.0;
this.m13 = 0.0;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix to the matrix conversion of the
* single precision axis and angle argument.
* @param a1 the axis and angle to be converted
*/
public final void set(AxisAngle4f a1)
{
double mag = Math.sqrt( a1.x*a1.x + a1.y*a1.y + a1.z*a1.z);
if( mag < EPS ) {
m00 = 1.0;
m01 = 0.0;
m02 = 0.0;
m10 = 0.0;
m11 = 1.0;
m12 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 1.0;
} else {
mag = 1.0/mag;
double ax = a1.x*mag;
double ay = a1.y*mag;
double az = a1.z*mag;
double sinTheta = Math.sin((double)a1.angle);
double cosTheta = Math.cos((double)a1.angle);
double t = 1.0 - cosTheta;
double xz = ax * az;
double xy = ax * ay;
double yz = ay * az;
m00 = t * ax * ax + cosTheta;
m01 = t * xy - sinTheta * az;
m02 = t * xz + sinTheta * ay;
m10 = t * xy + sinTheta * az;
m11 = t * ay * ay + cosTheta;
m12 = t * yz - sinTheta * ax;
m20 = t * xz - sinTheta * ay;
m21 = t * yz + sinTheta * ax;
m22 = t * az * az + cosTheta;
}
m03 = 0.0;
m13 = 0.0;
m23 = 0.0;
m30 = 0.0;
m31 = 0.0;
m32 = 0.0;
m33 = 1.0;
}
/**
* Sets the value of this matrix from the rotation expressed
* by the quaternion q1, the translation t1, and the scale s.
* @param q1 the rotation expressed as a quaternion
* @param t1 the translation
* @param s the scale value
*/
public final void set(Quat4d q1, Vector3d t1, double s)
{
this.m00 = s*(1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = s*(2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = s*(2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = s*(2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = s*(2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = s*(2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = s*(2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
this.m03 = t1.x;
this.m13 = t1.y;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix from the rotation expressed
* by the quaternion q1, the translation t1, and the scale s.
* @param q1 the rotation expressed as a quaternion
* @param t1 the translation
* @param s the scale value
*/
public final void set(Quat4f q1, Vector3d t1, double s)
{
this.m00 = s*(1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = s*(2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = s*(2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = s*(2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = s*(2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = s*(2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = s*(2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
this.m03 = t1.x;
this.m13 = t1.y;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix from the rotation expressed
* by the quaternion q1, the translation t1, and the scale s.
* @param q1 the rotation expressed as a quaternion
* @param t1 the translation
* @param s the scale value
*/
public final void set(Quat4f q1, Vector3f t1, float s)
{
this.m00 = s*(1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = s*(2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = s*(2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = s*(2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = s*(2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = s*(2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = s*(2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = s*(1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
this.m03 = t1.x;
this.m13 = t1.y;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix to a copy of the
* passed matrix m1.
* @param m1 the matrix4f
*/
public final void set(Matrix4f m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m03 = m1.m03;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m13 = m1.m13;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
this.m23 = m1.m23;
this.m30 = m1.m30;
this.m31 = m1.m31;
this.m32 = m1.m32;
this.m33 = m1.m33;
}
/**
* Sets the value of this matrix to a copy of the
* passed matrix m1.
* @param m1 the matrix to be copied
*/
public final void set(Matrix4d m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m03 = m1.m03;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m13 = m1.m13;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
this.m23 = m1.m23;
this.m30 = m1.m30;
this.m31 = m1.m31;
this.m32 = m1.m32;
this.m33 = m1.m33;
}
/**
* Sets the value of this matrix to the matrix inverse
* of the passed (user declared) matrix m1.
* @param m1 the matrix to be inverted
*/
public final void invert(Matrix4d m1)
{
invertGeneral( m1);
}
/**
* Inverts this matrix in place.
*/
public final void invert()
{
invertGeneral( this );
}
/**
* General invert routine. Inverts m1 and places the result in "this".
* Note that this routine handles both the "this" version and the
* non-"this" version.
*
* Also note that since this routine is slow anyway, we won't worry
* about allocating a little bit of garbage.
*/
final void invertGeneral(Matrix4d m1) {
double result[] = new double[16];
int row_perm[] = new int[4];
int i, r, c;
// Use LU decomposition and backsubstitution code specifically
// for floating-point 4x4 matrices.
double[] tmp = new double[16]; // scratch matrix
// Copy source matrix to t1tmp
tmp[0] = m1.m00;
tmp[1] = m1.m01;
tmp[2] = m1.m02;
tmp[3] = m1.m03;
tmp[4] = m1.m10;
tmp[5] = m1.m11;
tmp[6] = m1.m12;
tmp[7] = m1.m13;
tmp[8] = m1.m20;
tmp[9] = m1.m21;
tmp[10] = m1.m22;
tmp[11] = m1.m23;
tmp[12] = m1.m30;
tmp[13] = m1.m31;
tmp[14] = m1.m32;
tmp[15] = m1.m33;
// Calculate LU decomposition: Is the matrix singular?
if (!luDecomposition(tmp, row_perm)) {
// Matrix has no inverse
throw new SingularMatrixException(VecMathI18N.getString("Matrix4d10"));
}
// Perform back substitution on the identity matrix
for(i=0;i<16;i++) result[i] = 0.0;
result[0] = 1.0; result[5] = 1.0; result[10] = 1.0; result[15] = 1.0;
luBacksubstitution(tmp, row_perm, result);
this.m00 = result[0];
this.m01 = result[1];
this.m02 = result[2];
this.m03 = result[3];
this.m10 = result[4];
this.m11 = result[5];
this.m12 = result[6];
this.m13 = result[7];
this.m20 = result[8];
this.m21 = result[9];
this.m22 = result[10];
this.m23 = result[11];
this.m30 = result[12];
this.m31 = result[13];
this.m32 = result[14];
this.m33 = result[15];
}
/**
* Given a 4x4 array "matrix0", this function replaces it with the
* LU decomposition of a row-wise permutation of itself. The input
* parameters are "matrix0" and "dimen". The array "matrix0" is also
* an output parameter. The vector "row_perm[4]" is an output
* parameter that contains the row permutations resulting from partial
* pivoting. The output parameter "even_row_xchg" is 1 when the
* number of row exchanges is even, or -1 otherwise. Assumes data
* type is always double.
*
* This function is similar to luDecomposition, except that it
* is tuned specifically for 4x4 matrices.
*
* @return true if the matrix is nonsingular, or false otherwise.
*/
//
// Reference: Press, Flannery, Teukolsky, Vetterling,
// _Numerical_Recipes_in_C_, Cambridge University Press,
// 1988, pp 40-45.
//
static boolean luDecomposition(double[] matrix0,
int[] row_perm) {
double row_scale[] = new double[4];
// Determine implicit scaling information by looping over rows
{
int i, j;
int ptr, rs;
double big, temp;
ptr = 0;
rs = 0;
// For each row ...
i = 4;
while (i-- != 0) {
big = 0.0;
// For each column, find the largest element in the row
j = 4;
while (j-- != 0) {
temp = matrix0[ptr++];
temp = Math.abs(temp);
if (temp > big) {
big = temp;
}
}
// Is the matrix singular?
if (big == 0.0) {
return false;
}
row_scale[rs++] = 1.0 / big;
}
}
{
int j;
int mtx;
mtx = 0;
// For all columns, execute Crout's method
for (j = 0; j < 4; j++) {
int i, imax, k;
int target, p1, p2;
double sum, big, temp;
// Determine elements of upper diagonal matrix U
for (i = 0; i < j; i++) {
target = mtx + (4*i) + j;
sum = matrix0[target];
k = i;
p1 = mtx + (4*i);
p2 = mtx + j;
while (k-- != 0) {
sum -= matrix0[p1] * matrix0[p2];
p1++;
p2 += 4;
}
matrix0[target] = sum;
}
// Search for largest pivot element and calculate
// intermediate elements of lower diagonal matrix L.
big = 0.0;
imax = -1;
for (i = j; i < 4; i++) {
target = mtx + (4*i) + j;
sum = matrix0[target];
k = j;
p1 = mtx + (4*i);
p2 = mtx + j;
while (k-- != 0) {
sum -= matrix0[p1] * matrix0[p2];
p1++;
p2 += 4;
}
matrix0[target] = sum;
// Is this the best pivot so far?
if ((temp = row_scale[i] * Math.abs(sum)) >= big) {
big = temp;
imax = i;
}
}
if (imax < 0) {
throw new RuntimeException(VecMathI18N.getString("Matrix4d11"));
}
// Is a row exchange necessary?
if (j != imax) {
// Yes: exchange rows
k = 4;
p1 = mtx + (4*imax);
p2 = mtx + (4*j);
while (k-- != 0) {
temp = matrix0[p1];
matrix0[p1++] = matrix0[p2];
matrix0[p2++] = temp;
}
// Record change in scale factor
row_scale[imax] = row_scale[j];
}
// Record row permutation
row_perm[j] = imax;
// Is the matrix singular
if (matrix0[(mtx + (4*j) + j)] == 0.0) {
return false;
}
// Divide elements of lower diagonal matrix L by pivot
if (j != (4-1)) {
temp = 1.0 / (matrix0[(mtx + (4*j) + j)]);
target = mtx + (4*(j+1)) + j;
i = 3 - j;
while (i-- != 0) {
matrix0[target] *= temp;
target += 4;
}
}
}
}
return true;
}
/**
* Solves a set of linear equations. The input parameters "matrix1",
* and "row_perm" come from luDecompostionD4x4 and do not change
* here. The parameter "matrix2" is a set of column vectors assembled
* into a 4x4 matrix of floating-point values. The procedure takes each
* column of "matrix2" in turn and treats it as the right-hand side of the
* matrix equation Ax = LUx = b. The solution vector replaces the
* original column of the matrix.
*
* If "matrix2" is the identity matrix, the procedure replaces its contents
* with the inverse of the matrix from which "matrix1" was originally
* derived.
*/
//
// Reference: Press, Flannery, Teukolsky, Vetterling,
// _Numerical_Recipes_in_C_, Cambridge University Press,
// 1988, pp 44-45.
//
static void luBacksubstitution(double[] matrix1,
int[] row_perm,
double[] matrix2) {
int i, ii, ip, j, k;
int rp;
int cv, rv;
// rp = row_perm;
rp = 0;
// For each column vector of matrix2 ...
for (k = 0; k < 4; k++) {
// cv = &(matrix2[0][k]);
cv = k;
ii = -1;
// Forward substitution
for (i = 0; i < 4; i++) {
double sum;
ip = row_perm[rp+i];
sum = matrix2[cv+4*ip];
matrix2[cv+4*ip] = matrix2[cv+4*i];
if (ii >= 0) {
// rv = &(matrix1[i][0]);
rv = i*4;
for (j = ii; j <= i-1; j++) {
sum -= matrix1[rv+j] * matrix2[cv+4*j];
}
}
else if (sum != 0.0) {
ii = i;
}
matrix2[cv+4*i] = sum;
}
// Backsubstitution
// rv = &(matrix1[3][0]);
rv = 3*4;
matrix2[cv+4*3] /= matrix1[rv+3];
rv -= 4;
matrix2[cv+4*2] = (matrix2[cv+4*2] -
matrix1[rv+3] * matrix2[cv+4*3]) / matrix1[rv+2];
rv -= 4;
matrix2[cv+4*1] = (matrix2[cv+4*1] -
matrix1[rv+2] * matrix2[cv+4*2] -
matrix1[rv+3] * matrix2[cv+4*3]) / matrix1[rv+1];
rv -= 4;
matrix2[cv+4*0] = (matrix2[cv+4*0] -
matrix1[rv+1] * matrix2[cv+4*1] -
matrix1[rv+2] * matrix2[cv+4*2] -
matrix1[rv+3] * matrix2[cv+4*3]) / matrix1[rv+0];
}
}
/**
* Computes the determinant of this matrix.
* @return the determinant of the matrix
*/
public final double determinant()
{
double det;
// cofactor exapainsion along first row
det = m00*(m11*m22*m33+ m12*m23*m31 + m13*m21*m32
- m13*m22*m31 -m11*m23*m32 - m12*m21*m33);
det -= m01*(m10*m22*m33+ m12*m23*m30 + m13*m20*m32
- m13*m22*m30 -m10*m23*m32 - m12*m20*m33);
det += m02*(m10*m21*m33+ m11*m23*m30 + m13*m20*m31
- m13*m21*m30 -m10*m23*m31 - m11*m20*m33);
det -= m03*(m10*m21*m32+ m11*m22*m30 + m12*m20*m31
- m12*m21*m30 -m10*m22*m31 - m11*m20*m32);
return( det );
}
/**
* Sets the value of this matrix to a scale matrix with the
* passed scale amount.
* @param scale the scale factor for the matrix
*/
public final void set(double scale)
{
this.m00 = scale;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = 0.0;
this.m10 = 0.0;
this.m11 = scale;
this.m12 = 0.0;
this.m13 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = scale;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix to a translate matrix by the
* passed translation value.
* @param v1 the translation amount
*/
public final void set(Vector3d v1)
{
this.m00 = 1.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = v1.x;
this.m10 = 0.0;
this.m11 = 1.0;
this.m12 = 0.0;
this.m13 = v1.y;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 1.0;
this.m23 = v1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this transform to a scale and translation matrix;
* the scale is not applied to the translation and all of the matrix
* values are modified.
* @param scale the scale factor for the matrix
* @param v1 the translation amount
*/
public final void set(double scale, Vector3d v1)
{
this.m00 = scale;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = v1.x;
this.m10 = 0.0;
this.m11 = scale;
this.m12 = 0.0;
this.m13 = v1.y;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = scale;
this.m23 = v1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this transform to a scale and translation matrix;
* the translation is scaled by the scale factor and all of the matrix
* values are modified.
* @param v1 the translation amount
* @param scale the scale factor for the matrix
*/
public final void set(Vector3d v1, double scale)
{
this.m00 = scale;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = scale*v1.x;
this.m10 = 0.0;
this.m11 = scale;
this.m12 = 0.0;
this.m13 = scale*v1.y;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = scale;
this.m23 = scale*v1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix from the rotation expressed by
* the rotation matrix m1, the translation t1, and the scale factor.
* The translation is not modified by the scale.
* @param m1 the rotation component
* @param t1 the translation component
* @param scale the scale component
*/
public final void set(Matrix3f m1, Vector3f t1, float scale)
{
this.m00 = m1.m00*scale;
this.m01 = m1.m01*scale;
this.m02 = m1.m02*scale;
this.m03 = t1.x;
this.m10 = m1.m10*scale;
this.m11 = m1.m11*scale;
this.m12 = m1.m12*scale;
this.m13 = t1.y;
this.m20 = m1.m20*scale;
this.m21 = m1.m21*scale;
this.m22 = m1.m22*scale;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix from the rotation expressed by
* the rotation matrix m1, the translation t1, and the scale factor.
* The translation is not modified by the scale.
* @param m1 the rotation component
* @param t1 the translation component
* @param scale the scale component
*/
public final void set(Matrix3d m1, Vector3d t1, double scale)
{
this.m00 = m1.m00*scale;
this.m01 = m1.m01*scale;
this.m02 = m1.m02*scale;
this.m03 = t1.x;
this.m10 = m1.m10*scale;
this.m11 = m1.m11*scale;
this.m12 = m1.m12*scale;
this.m13 = t1.y;
this.m20 = m1.m20*scale;
this.m21 = m1.m21*scale;
this.m22 = m1.m22*scale;
this.m23 = t1.z;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Modifies the translational components of this matrix to the values
* of the Vector3d argument; the other values of this matrix are not
* modified.
* @param trans the translational component
*/
public final void setTranslation(Vector3d trans)
{
m03 = trans.x;
m13 = trans.y;
m23 = trans.z;
}
/**
* Sets the value of this matrix to a counter-clockwise rotation
* about the x axis.
* @param angle the angle to rotate about the X axis in radians
*/
public final void rotX(double angle)
{
double sinAngle, cosAngle;
sinAngle = Math.sin(angle);
cosAngle = Math.cos(angle);
this.m00 = 1.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m03 = 0.0;
this.m10 = 0.0;
this.m11 = cosAngle;
this.m12 = -sinAngle;
this.m13 = 0.0;
this.m20 = 0.0;
this.m21 = sinAngle;
this.m22 = cosAngle;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix to a counter-clockwise rotation
* about the y axis.
* @param angle the angle to rotate about the Y axis in radians
*/
public final void rotY(double angle)
{
double sinAngle, cosAngle;
sinAngle = Math.sin(angle);
cosAngle = Math.cos(angle);
this.m00 = cosAngle;
this.m01 = 0.0;
this.m02 = sinAngle;
this.m03 = 0.0;
this.m10 = 0.0;
this.m11 = 1.0;
this.m12 = 0.0;
this.m13 = 0.0;
this.m20 = -sinAngle;
this.m21 = 0.0;
this.m22 = cosAngle;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Sets the value of this matrix to a counter-clockwise rotation
* about the z axis.
* @param angle the angle to rotate about the Z axis in radians
*/
public final void rotZ(double angle)
{
double sinAngle, cosAngle;
sinAngle = Math.sin(angle);
cosAngle = Math.cos(angle);
this.m00 = cosAngle;
this.m01 = -sinAngle;
this.m02 = 0.0;
this.m03 = 0.0;
this.m10 = sinAngle;
this.m11 = cosAngle;
this.m12 = 0.0;
this.m13 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 1.0;
this.m23 = 0.0;
this.m30 = 0.0;
this.m31 = 0.0;
this.m32 = 0.0;
this.m33 = 1.0;
}
/**
* Multiplies each element of this matrix by a scalar.
* @param scalar the scalar multiplier.
*/
public final void mul(double scalar)
{
m00 *= scalar;
m01 *= scalar;
m02 *= scalar;
m03 *= scalar;
m10 *= scalar;
m11 *= scalar;
m12 *= scalar;
m13 *= scalar;
m20 *= scalar;
m21 *= scalar;
m22 *= scalar;
m23 *= scalar;
m30 *= scalar;
m31 *= scalar;
m32 *= scalar;
m33 *= scalar;
}
/**
* Multiplies each element of matrix m1 by a scalar and places
* the result into this. Matrix m1 is not modified.
* @param scalar the scalar multiplier
* @param m1 the original matrix
*/
public final void mul(double scalar, Matrix4d m1)
{
this.m00 = m1.m00 * scalar;
this.m01 = m1.m01 * scalar;
this.m02 = m1.m02 * scalar;
this.m03 = m1.m03 * scalar;
this.m10 = m1.m10 * scalar;
this.m11 = m1.m11 * scalar;
this.m12 = m1.m12 * scalar;
this.m13 = m1.m13 * scalar;
this.m20 = m1.m20 * scalar;
this.m21 = m1.m21 * scalar;
this.m22 = m1.m22 * scalar;
this.m23 = m1.m23 * scalar;
this.m30 = m1.m30 * scalar;
this.m31 = m1.m31 * scalar;
this.m32 = m1.m32 * scalar;
this.m33 = m1.m33 * scalar;
}
/**
* Sets the value of this matrix to the result of multiplying itself
* with matrix m1.
* @param m1 the other matrix
*/
public final void mul(Matrix4d m1)
{
double m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23,
m30, m31, m32, m33; // vars for temp result matrix
m00 = this.m00*m1.m00 + this.m01*m1.m10 +
this.m02*m1.m20 + this.m03*m1.m30;
m01 = this.m00*m1.m01 + this.m01*m1.m11 +
this.m02*m1.m21 + this.m03*m1.m31;
m02 = this.m00*m1.m02 + this.m01*m1.m12 +
this.m02*m1.m22 + this.m03*m1.m32;
m03 = this.m00*m1.m03 + this.m01*m1.m13 +
this.m02*m1.m23 + this.m03*m1.m33;
m10 = this.m10*m1.m00 + this.m11*m1.m10 +
this.m12*m1.m20 + this.m13*m1.m30;
m11 = this.m10*m1.m01 + this.m11*m1.m11 +
this.m12*m1.m21 + this.m13*m1.m31;
m12 = this.m10*m1.m02 + this.m11*m1.m12 +
this.m12*m1.m22 + this.m13*m1.m32;
m13 = this.m10*m1.m03 + this.m11*m1.m13 +
this.m12*m1.m23 + this.m13*m1.m33;
m20 = this.m20*m1.m00 + this.m21*m1.m10 +
this.m22*m1.m20 + this.m23*m1.m30;
m21 = this.m20*m1.m01 + this.m21*m1.m11 +
this.m22*m1.m21 + this.m23*m1.m31;
m22 = this.m20*m1.m02 + this.m21*m1.m12 +
this.m22*m1.m22 + this.m23*m1.m32;
m23 = this.m20*m1.m03 + this.m21*m1.m13 +
this.m22*m1.m23 + this.m23*m1.m33;
m30 = this.m30*m1.m00 + this.m31*m1.m10 +
this.m32*m1.m20 + this.m33*m1.m30;
m31 = this.m30*m1.m01 + this.m31*m1.m11 +
this.m32*m1.m21 + this.m33*m1.m31;
m32 = this.m30*m1.m02 + this.m31*m1.m12 +
this.m32*m1.m22 + this.m33*m1.m32;
m33 = this.m30*m1.m03 + this.m31*m1.m13 +
this.m32*m1.m23 + this.m33*m1.m33;
this.m00 = m00; this.m01 = m01; this.m02 = m02; this.m03 = m03;
this.m10 = m10; this.m11 = m11; this.m12 = m12; this.m13 = m13;
this.m20 = m20; this.m21 = m21; this.m22 = m22; this.m23 = m23;
this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
}
/**
* Sets the value of this matrix to the result of multiplying
* the two argument matrices together.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void mul(Matrix4d m1, Matrix4d m2)
{
if (this != m1 && this != m2) {
// code for mat mul
this.m00 = m1.m00*m2.m00 + m1.m01*m2.m10 +
m1.m02*m2.m20 + m1.m03*m2.m30;
this.m01 = m1.m00*m2.m01 + m1.m01*m2.m11 +
m1.m02*m2.m21 + m1.m03*m2.m31;
this.m02 = m1.m00*m2.m02 + m1.m01*m2.m12 +
m1.m02*m2.m22 + m1.m03*m2.m32;
this.m03 = m1.m00*m2.m03 + m1.m01*m2.m13 +
m1.m02*m2.m23 + m1.m03*m2.m33;
this.m10 = m1.m10*m2.m00 + m1.m11*m2.m10 +
m1.m12*m2.m20 + m1.m13*m2.m30;
this.m11 = m1.m10*m2.m01 + m1.m11*m2.m11 +
m1.m12*m2.m21 + m1.m13*m2.m31;
this.m12 = m1.m10*m2.m02 + m1.m11*m2.m12 +
m1.m12*m2.m22 + m1.m13*m2.m32;
this.m13 = m1.m10*m2.m03 + m1.m11*m2.m13 +
m1.m12*m2.m23 + m1.m13*m2.m33;
this.m20 = m1.m20*m2.m00 + m1.m21*m2.m10 +
m1.m22*m2.m20 + m1.m23*m2.m30;
this.m21 = m1.m20*m2.m01 + m1.m21*m2.m11 +
m1.m22*m2.m21 + m1.m23*m2.m31;
this.m22 = m1.m20*m2.m02 + m1.m21*m2.m12 +
m1.m22*m2.m22 + m1.m23*m2.m32;
this.m23 = m1.m20*m2.m03 + m1.m21*m2.m13 +
m1.m22*m2.m23 + m1.m23*m2.m33;
this.m30 = m1.m30*m2.m00 + m1.m31*m2.m10 +
m1.m32*m2.m20 + m1.m33*m2.m30;
this.m31 = m1.m30*m2.m01 + m1.m31*m2.m11 +
m1.m32*m2.m21 + m1.m33*m2.m31;
this.m32 = m1.m30*m2.m02 + m1.m31*m2.m12 +
m1.m32*m2.m22 + m1.m33*m2.m32;
this.m33 = m1.m30*m2.m03 + m1.m31*m2.m13 +
m1.m32*m2.m23 + m1.m33*m2.m33;
} else {
double m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23,
m30, m31, m32, m33; // vars for temp result matrix
// code for mat mul
m00 = m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20 + m1.m03*m2.m30;
m01 = m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21 + m1.m03*m2.m31;
m02 = m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22 + m1.m03*m2.m32;
m03 = m1.m00*m2.m03 + m1.m01*m2.m13 + m1.m02*m2.m23 + m1.m03*m2.m33;
m10 = m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20 + m1.m13*m2.m30;
m11 = m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21 + m1.m13*m2.m31;
m12 = m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22 + m1.m13*m2.m32;
m13 = m1.m10*m2.m03 + m1.m11*m2.m13 + m1.m12*m2.m23 + m1.m13*m2.m33;
m20 = m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20 + m1.m23*m2.m30;
m21 = m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21 + m1.m23*m2.m31;
m22 = m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22 + m1.m23*m2.m32;
m23 = m1.m20*m2.m03 + m1.m21*m2.m13 + m1.m22*m2.m23 + m1.m23*m2.m33;
m30 = m1.m30*m2.m00 + m1.m31*m2.m10 + m1.m32*m2.m20 + m1.m33*m2.m30;
m31 = m1.m30*m2.m01 + m1.m31*m2.m11 + m1.m32*m2.m21 + m1.m33*m2.m31;
m32 = m1.m30*m2.m02 + m1.m31*m2.m12 + m1.m32*m2.m22 + m1.m33*m2.m32;
m33 = m1.m30*m2.m03 + m1.m31*m2.m13 + m1.m32*m2.m23 + m1.m33*m2.m33;
this.m00 = m00; this.m01 = m01; this.m02 = m02; this.m03 = m03;
this.m10 = m10; this.m11 = m11; this.m12 = m12; this.m13 = m13;
this.m20 = m20; this.m21 = m21; this.m22 = m22; this.m23 = m23;
this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
}
}
/**
* Multiplies the transpose of matrix m1 times the transpose of matrix
* m2, and places the result into this.
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulTransposeBoth(Matrix4d m1, Matrix4d m2)
{
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m10*m2.m01 + m1.m20*m2.m02 + m1.m30*m2.m03;
this.m01 = m1.m00*m2.m10 + m1.m10*m2.m11 + m1.m20*m2.m12 + m1.m30*m2.m13;
this.m02 = m1.m00*m2.m20 + m1.m10*m2.m21 + m1.m20*m2.m22 + m1.m30*m2.m23;
this.m03 = m1.m00*m2.m30 + m1.m10*m2.m31 + m1.m20*m2.m32 + m1.m30*m2.m33;
this.m10 = m1.m01*m2.m00 + m1.m11*m2.m01 + m1.m21*m2.m02 + m1.m31*m2.m03;
this.m11 = m1.m01*m2.m10 + m1.m11*m2.m11 + m1.m21*m2.m12 + m1.m31*m2.m13;
this.m12 = m1.m01*m2.m20 + m1.m11*m2.m21 + m1.m21*m2.m22 + m1.m31*m2.m23;
this.m13 = m1.m01*m2.m30 + m1.m11*m2.m31 + m1.m21*m2.m32 + m1.m31*m2.m33;
this.m20 = m1.m02*m2.m00 + m1.m12*m2.m01 + m1.m22*m2.m02 + m1.m32*m2.m03;
this.m21 = m1.m02*m2.m10 + m1.m12*m2.m11 + m1.m22*m2.m12 + m1.m32*m2.m13;
this.m22 = m1.m02*m2.m20 + m1.m12*m2.m21 + m1.m22*m2.m22 + m1.m32*m2.m23;
this.m23 = m1.m02*m2.m30 + m1.m12*m2.m31 + m1.m22*m2.m32 + m1.m32*m2.m33;
this.m30 = m1.m03*m2.m00 + m1.m13*m2.m01 + m1.m23*m2.m02 + m1.m33*m2.m03;
this.m31 = m1.m03*m2.m10 + m1.m13*m2.m11 + m1.m23*m2.m12 + m1.m33*m2.m13;
this.m32 = m1.m03*m2.m20 + m1.m13*m2.m21 + m1.m23*m2.m22 + m1.m33*m2.m23;
this.m33 = m1.m03*m2.m30 + m1.m13*m2.m31 + m1.m23*m2.m32 + m1.m33*m2.m33;
} else {
double m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23, // vars for temp result matrix
m30, m31, m32, m33;
m00 = m1.m00*m2.m00 + m1.m10*m2.m01 + m1.m20*m2.m02 + m1.m30*m2.m03;
m01 = m1.m00*m2.m10 + m1.m10*m2.m11 + m1.m20*m2.m12 + m1.m30*m2.m13;
m02 = m1.m00*m2.m20 + m1.m10*m2.m21 + m1.m20*m2.m22 + m1.m30*m2.m23;
m03 = m1.m00*m2.m30 + m1.m10*m2.m31 + m1.m20*m2.m32 + m1.m30*m2.m33;
m10 = m1.m01*m2.m00 + m1.m11*m2.m01 + m1.m21*m2.m02 + m1.m31*m2.m03;
m11 = m1.m01*m2.m10 + m1.m11*m2.m11 + m1.m21*m2.m12 + m1.m31*m2.m13;
m12 = m1.m01*m2.m20 + m1.m11*m2.m21 + m1.m21*m2.m22 + m1.m31*m2.m23;
m13 = m1.m01*m2.m30 + m1.m11*m2.m31 + m1.m21*m2.m32 + m1.m31*m2.m33;
m20 = m1.m02*m2.m00 + m1.m12*m2.m01 + m1.m22*m2.m02 + m1.m32*m2.m03;
m21 = m1.m02*m2.m10 + m1.m12*m2.m11 + m1.m22*m2.m12 + m1.m32*m2.m13;
m22 = m1.m02*m2.m20 + m1.m12*m2.m21 + m1.m22*m2.m22 + m1.m32*m2.m23;
m23 = m1.m02*m2.m30 + m1.m12*m2.m31 + m1.m22*m2.m32 + m1.m32*m2.m33;
m30 = m1.m03*m2.m00 + m1.m13*m2.m01 + m1.m23*m2.m02 + m1.m33*m2.m03;
m31 = m1.m03*m2.m10 + m1.m13*m2.m11 + m1.m23*m2.m12 + m1.m33*m2.m13;
m32 = m1.m03*m2.m20 + m1.m13*m2.m21 + m1.m23*m2.m22 + m1.m33*m2.m23;
m33 = m1.m03*m2.m30 + m1.m13*m2.m31 + m1.m23*m2.m32 + m1.m33*m2.m33;
this.m00 = m00; this.m01 = m01; this.m02 = m02; this.m03 = m03;
this.m10 = m10; this.m11 = m11; this.m12 = m12; this.m13 = m13;
this.m20 = m20; this.m21 = m21; this.m22 = m22; this.m23 = m23;
this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
}
}
/**
* Multiplies matrix m1 times the transpose of matrix m2, and
* places the result into this.
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulTransposeRight(Matrix4d m1, Matrix4d m2)
{
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m01*m2.m01 + m1.m02*m2.m02 + m1.m03*m2.m03;
this.m01 = m1.m00*m2.m10 + m1.m01*m2.m11 + m1.m02*m2.m12 + m1.m03*m2.m13;
this.m02 = m1.m00*m2.m20 + m1.m01*m2.m21 + m1.m02*m2.m22 + m1.m03*m2.m23;
this.m03 = m1.m00*m2.m30 + m1.m01*m2.m31 + m1.m02*m2.m32 + m1.m03*m2.m33;
this.m10 = m1.m10*m2.m00 + m1.m11*m2.m01 + m1.m12*m2.m02 + m1.m13*m2.m03;
this.m11 = m1.m10*m2.m10 + m1.m11*m2.m11 + m1.m12*m2.m12 + m1.m13*m2.m13;
this.m12 = m1.m10*m2.m20 + m1.m11*m2.m21 + m1.m12*m2.m22 + m1.m13*m2.m23;
this.m13 = m1.m10*m2.m30 + m1.m11*m2.m31 + m1.m12*m2.m32 + m1.m13*m2.m33;
this.m20 = m1.m20*m2.m00 + m1.m21*m2.m01 + m1.m22*m2.m02 + m1.m23*m2.m03;
this.m21 = m1.m20*m2.m10 + m1.m21*m2.m11 + m1.m22*m2.m12 + m1.m23*m2.m13;
this.m22 = m1.m20*m2.m20 + m1.m21*m2.m21 + m1.m22*m2.m22 + m1.m23*m2.m23;
this.m23 = m1.m20*m2.m30 + m1.m21*m2.m31 + m1.m22*m2.m32 + m1.m23*m2.m33;
this.m30 = m1.m30*m2.m00 + m1.m31*m2.m01 + m1.m32*m2.m02 + m1.m33*m2.m03;
this.m31 = m1.m30*m2.m10 + m1.m31*m2.m11 + m1.m32*m2.m12 + m1.m33*m2.m13;
this.m32 = m1.m30*m2.m20 + m1.m31*m2.m21 + m1.m32*m2.m22 + m1.m33*m2.m23;
this.m33 = m1.m30*m2.m30 + m1.m31*m2.m31 + m1.m32*m2.m32 + m1.m33*m2.m33;
} else {
double m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23, // vars for temp result matrix
m30, m31, m32, m33;
m00 = m1.m00*m2.m00 + m1.m01*m2.m01 + m1.m02*m2.m02 + m1.m03*m2.m03;
m01 = m1.m00*m2.m10 + m1.m01*m2.m11 + m1.m02*m2.m12 + m1.m03*m2.m13;
m02 = m1.m00*m2.m20 + m1.m01*m2.m21 + m1.m02*m2.m22 + m1.m03*m2.m23;
m03 = m1.m00*m2.m30 + m1.m01*m2.m31 + m1.m02*m2.m32 + m1.m03*m2.m33;
m10 = m1.m10*m2.m00 + m1.m11*m2.m01 + m1.m12*m2.m02 + m1.m13*m2.m03;
m11 = m1.m10*m2.m10 + m1.m11*m2.m11 + m1.m12*m2.m12 + m1.m13*m2.m13;
m12 = m1.m10*m2.m20 + m1.m11*m2.m21 + m1.m12*m2.m22 + m1.m13*m2.m23;
m13 = m1.m10*m2.m30 + m1.m11*m2.m31 + m1.m12*m2.m32 + m1.m13*m2.m33;
m20 = m1.m20*m2.m00 + m1.m21*m2.m01 + m1.m22*m2.m02 + m1.m23*m2.m03;
m21 = m1.m20*m2.m10 + m1.m21*m2.m11 + m1.m22*m2.m12 + m1.m23*m2.m13;
m22 = m1.m20*m2.m20 + m1.m21*m2.m21 + m1.m22*m2.m22 + m1.m23*m2.m23;
m23 = m1.m20*m2.m30 + m1.m21*m2.m31 + m1.m22*m2.m32 + m1.m23*m2.m33;
m30 = m1.m30*m2.m00 + m1.m31*m2.m01 + m1.m32*m2.m02 + m1.m33*m2.m03;
m31 = m1.m30*m2.m10 + m1.m31*m2.m11 + m1.m32*m2.m12 + m1.m33*m2.m13;
m32 = m1.m30*m2.m20 + m1.m31*m2.m21 + m1.m32*m2.m22 + m1.m33*m2.m23;
m33 = m1.m30*m2.m30 + m1.m31*m2.m31 + m1.m32*m2.m32 + m1.m33*m2.m33;
this.m00 = m00; this.m01 = m01; this.m02 = m02; this.m03 = m03;
this.m10 = m10; this.m11 = m11; this.m12 = m12; this.m13 = m13;
this.m20 = m20; this.m21 = m21; this.m22 = m22; this.m23 = m23;
this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
}
}
/**
* Multiplies the transpose of matrix m1 times matrix m2, and
* places the result into this.
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulTransposeLeft(Matrix4d m1, Matrix4d m2)
{
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m10*m2.m10 + m1.m20*m2.m20 + m1.m30*m2.m30;
this.m01 = m1.m00*m2.m01 + m1.m10*m2.m11 + m1.m20*m2.m21 + m1.m30*m2.m31;
this.m02 = m1.m00*m2.m02 + m1.m10*m2.m12 + m1.m20*m2.m22 + m1.m30*m2.m32;
this.m03 = m1.m00*m2.m03 + m1.m10*m2.m13 + m1.m20*m2.m23 + m1.m30*m2.m33;
this.m10 = m1.m01*m2.m00 + m1.m11*m2.m10 + m1.m21*m2.m20 + m1.m31*m2.m30;
this.m11 = m1.m01*m2.m01 + m1.m11*m2.m11 + m1.m21*m2.m21 + m1.m31*m2.m31;
this.m12 = m1.m01*m2.m02 + m1.m11*m2.m12 + m1.m21*m2.m22 + m1.m31*m2.m32;
this.m13 = m1.m01*m2.m03 + m1.m11*m2.m13 + m1.m21*m2.m23 + m1.m31*m2.m33;
this.m20 = m1.m02*m2.m00 + m1.m12*m2.m10 + m1.m22*m2.m20 + m1.m32*m2.m30;
this.m21 = m1.m02*m2.m01 + m1.m12*m2.m11 + m1.m22*m2.m21 + m1.m32*m2.m31;
this.m22 = m1.m02*m2.m02 + m1.m12*m2.m12 + m1.m22*m2.m22 + m1.m32*m2.m32;
this.m23 = m1.m02*m2.m03 + m1.m12*m2.m13 + m1.m22*m2.m23 + m1.m32*m2.m33;
this.m30 = m1.m03*m2.m00 + m1.m13*m2.m10 + m1.m23*m2.m20 + m1.m33*m2.m30;
this.m31 = m1.m03*m2.m01 + m1.m13*m2.m11 + m1.m23*m2.m21 + m1.m33*m2.m31;
this.m32 = m1.m03*m2.m02 + m1.m13*m2.m12 + m1.m23*m2.m22 + m1.m33*m2.m32;
this.m33 = m1.m03*m2.m03 + m1.m13*m2.m13 + m1.m23*m2.m23 + m1.m33*m2.m33;
} else {
double m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23, // vars for temp result matrix
m30, m31, m32, m33;
m00 = m1.m00*m2.m00 + m1.m10*m2.m10 + m1.m20*m2.m20 + m1.m30*m2.m30;
m01 = m1.m00*m2.m01 + m1.m10*m2.m11 + m1.m20*m2.m21 + m1.m30*m2.m31;
m02 = m1.m00*m2.m02 + m1.m10*m2.m12 + m1.m20*m2.m22 + m1.m30*m2.m32;
m03 = m1.m00*m2.m03 + m1.m10*m2.m13 + m1.m20*m2.m23 + m1.m30*m2.m33;
m10 = m1.m01*m2.m00 + m1.m11*m2.m10 + m1.m21*m2.m20 + m1.m31*m2.m30;
m11 = m1.m01*m2.m01 + m1.m11*m2.m11 + m1.m21*m2.m21 + m1.m31*m2.m31;
m12 = m1.m01*m2.m02 + m1.m11*m2.m12 + m1.m21*m2.m22 + m1.m31*m2.m32;
m13 = m1.m01*m2.m03 + m1.m11*m2.m13 + m1.m21*m2.m23 + m1.m31*m2.m33;
m20 = m1.m02*m2.m00 + m1.m12*m2.m10 + m1.m22*m2.m20 + m1.m32*m2.m30;
m21 = m1.m02*m2.m01 + m1.m12*m2.m11 + m1.m22*m2.m21 + m1.m32*m2.m31;
m22 = m1.m02*m2.m02 + m1.m12*m2.m12 + m1.m22*m2.m22 + m1.m32*m2.m32;
m23 = m1.m02*m2.m03 + m1.m12*m2.m13 + m1.m22*m2.m23 + m1.m32*m2.m33;
m30 = m1.m03*m2.m00 + m1.m13*m2.m10 + m1.m23*m2.m20 + m1.m33*m2.m30;
m31 = m1.m03*m2.m01 + m1.m13*m2.m11 + m1.m23*m2.m21 + m1.m33*m2.m31;
m32 = m1.m03*m2.m02 + m1.m13*m2.m12 + m1.m23*m2.m22 + m1.m33*m2.m32;
m33 = m1.m03*m2.m03 + m1.m13*m2.m13 + m1.m23*m2.m23 + m1.m33*m2.m33;
this.m00 = m00; this.m01 = m01; this.m02 = m02; this.m03 = m03;
this.m10 = m10; this.m11 = m11; this.m12 = m12; this.m13 = m13;
this.m20 = m20; this.m21 = m21; this.m22 = m22; this.m23 = m23;
this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
}
}
/**
* Returns true if all of the data members of Matrix4d m1 are
* equal to the corresponding data members in this Matrix4d.
* @param m1 the matrix with which the comparison is made
* @return true or false
*/
public boolean equals(Matrix4d m1)
{
try {
return(this.m00 == m1.m00 && this.m01 == m1.m01 && this.m02 == m1.m02
&& this.m03 == m1.m03 && this.m10 == m1.m10 && this.m11 == m1.m11
&& this.m12 == m1.m12 && this.m13 == m1.m13 && this.m20 == m1.m20
&& this.m21 == m1.m21 && this.m22 == m1.m22 && this.m23 == m1.m23
&& this.m30 == m1.m30 && this.m31 == m1.m31 && this.m32 == m1.m32
&& this.m33 == m1.m33);
}
catch (NullPointerException e2) { return false; }
}
/**
* Returns true if the Object t1 is of type Matrix4d and all of the
* data members of t1 are equal to the corresponding data members in
* this Matrix4d.
* @param t1 the matrix with which the comparison is made
* @return true or false
*/
public boolean equals(Object t1)
{
try {
Matrix4d m2 = (Matrix4d) t1;
return(this.m00 == m2.m00 && this.m01 == m2.m01 && this.m02 == m2.m02
&& this.m03 == m2.m03 && this.m10 == m2.m10 && this.m11 == m2.m11
&& this.m12 == m2.m12 && this.m13 == m2.m13 && this.m20 == m2.m20
&& this.m21 == m2.m21 && this.m22 == m2.m22 && this.m23 == m2.m23
&& this.m30 == m2.m30 && this.m31 == m2.m31 && this.m32 == m2.m32
&& this.m33 == m2.m33);
}
catch (ClassCastException e1) { return false; }
catch (NullPointerException e2) { return false; }
}
/**
* @deprecated Use epsilonEquals(Matrix4d,double) instead
*/
public boolean epsilonEquals(Matrix4d m1, float epsilon) {
return epsilonEquals(m1, (double)epsilon);
}
/**
* Returns true if the L-infinite distance between this matrix
* and matrix m1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to
* MAX[i=0,1,2,3 ; j=0,1,2,3 ; abs(this.m(i,j) - m1.m(i,j)]
* @param m1 the matrix to be compared to this matrix
* @param epsilon the threshold value
*/
public boolean epsilonEquals(Matrix4d m1, double epsilon) {
double diff;
diff = m00 - m1.m00;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m01 - m1.m01;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m02 - m1.m02;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m03 - m1.m03;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m10 - m1.m10;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m11 - m1.m11;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m12 - m1.m12;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m13 - m1.m13;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m20 - m1.m20;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m21 - m1.m21;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m22 - m1.m22;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m23 - m1.m23;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m30 - m1.m30;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m31 - m1.m31;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m32 - m1.m32;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m33 - m1.m33;
if((diff<0?-diff:diff) > epsilon) return false;
return true;
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Matrix4d objects with identical data values
* (i.e., Matrix4d.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + VecMathUtil.doubleToLongBits(m00);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m01);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m02);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m03);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m10);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m11);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m12);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m13);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m20);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m21);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m22);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m23);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m30);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m31);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m32);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m33);
return (int) (bits ^ (bits >> 32));
}
/**
* Transform the vector vec using this Matrix4d and place the
* result into vecOut.
* @param vec the double precision vector to be transformed
* @param vecOut the vector into which the transformed values are placed
*/
public final void transform(Tuple4d vec, Tuple4d vecOut)
{
double x,y,z,w;
x = (m00*vec.x + m01*vec.y
+ m02*vec.z + m03*vec.w);
y = (m10*vec.x + m11*vec.y
+ m12*vec.z + m13*vec.w);
z = (m20*vec.x + m21*vec.y
+ m22*vec.z + m23*vec.w);
vecOut.w = (m30*vec.x + m31*vec.y
+ m32*vec.z + m33*vec.w);
vecOut.x = x;
vecOut.y = y;
vecOut.z = z;
}
/**
* Transform the vector vec using this Matrix4d and place the
* result back into vec.
* @param vec the double precision vector to be transformed
*/
public final void transform(Tuple4d vec)
{
double x,y,z;
x = (m00*vec.x + m01*vec.y
+ m02*vec.z + m03*vec.w);
y = (m10*vec.x + m11*vec.y
+ m12*vec.z + m13*vec.w);
z = (m20*vec.x + m21*vec.y
+ m22*vec.z + m23*vec.w);
vec.w = (m30*vec.x + m31*vec.y
+ m32*vec.z + m33*vec.w);
vec.x = x;
vec.y = y;
vec.z = z;
}
/**
* Transform the vector vec using this Matrix4d and place the
* result into vecOut.
* @param vec the single precision vector to be transformed
* @param vecOut the vector into which the transformed values are placed
*/
public final void transform(Tuple4f vec, Tuple4f vecOut)
{
float x,y,z;
x = (float) (m00*vec.x + m01*vec.y
+ m02*vec.z + m03*vec.w);
y = (float) (m10*vec.x + m11*vec.y
+ m12*vec.z + m13*vec.w);
z = (float) (m20*vec.x + m21*vec.y
+ m22*vec.z + m23*vec.w);
vecOut.w = (float) (m30*vec.x + m31*vec.y
+ m32*vec.z + m33*vec.w);
vecOut.x = x;
vecOut.y = y;
vecOut.z = z;
}
/**
* Transform the vector vec using this Transform and place the
* result back into vec.
* @param vec the single precision vector to be transformed
*/
public final void transform(Tuple4f vec)
{
float x,y,z;
x = (float) (m00*vec.x + m01*vec.y
+ m02*vec.z + m03*vec.w);
y = (float) (m10*vec.x + m11*vec.y
+ m12*vec.z + m13*vec.w);
z = (float) (m20*vec.x + m21*vec.y
+ m22*vec.z + m23*vec.w);
vec.w = (float) (m30*vec.x + m31*vec.y
+ m32*vec.z + m33*vec.w);
vec.x = x;
vec.y = y;
vec.z = z;
}
/**
* Transforms the point parameter with this Matrix4d and
* places the result into pointOut. The fourth element of the
* point input parameter is assumed to be one.
* @param point the input point to be transformed.
* @param pointOut the transformed point
*/
public final void transform(Point3d point, Point3d pointOut)
{
double x,y;
x = m00*point.x + m01*point.y + m02*point.z + m03;
y = m10*point.x + m11*point.y + m12*point.z + m13;
pointOut.z = m20*point.x + m21*point.y + m22*point.z + m23;
pointOut.x = x;
pointOut.y = y;
}
/**
* Transforms the point parameter with this Matrix4d and
* places the result back into point. The fourth element of the
* point input parameter is assumed to be one.
* @param point the input point to be transformed.
*/
public final void transform(Point3d point)
{
double x, y;
x = m00*point.x + m01*point.y + m02*point.z + m03;
y = m10*point.x + m11*point.y + m12*point.z + m13;
point.z = m20*point.x + m21*point.y + m22*point.z + m23;
point.x = x;
point.y = y;
}
/**
* Transforms the point parameter with this Matrix4d and
* places the result into pointOut. The fourth element of the
* point input parameter is assumed to be one.
* @param point the input point to be transformed.
* @param pointOut the transformed point
*/
public final void transform(Point3f point, Point3f pointOut)
{
float x,y;
x = (float) (m00*point.x + m01*point.y + m02*point.z + m03);
y = (float) (m10*point.x + m11*point.y + m12*point.z + m13);
pointOut.z = (float) (m20*point.x + m21*point.y + m22*point.z + m23);
pointOut.x = x;
pointOut.y = y;
}
/**
* Transforms the point parameter with this Matrix4d and
* places the result back into point. The fourth element of the
* point input parameter is assumed to be one.
* @param point the input point to be transformed.
*/
public final void transform(Point3f point)
{
float x, y;
x = (float) (m00*point.x + m01*point.y + m02*point.z + m03);
y = (float) (m10*point.x + m11*point.y + m12*point.z + m13);
point.z = (float) (m20*point.x + m21*point.y + m22*point.z + m23);
point.x = x;
point.y = y;
}
/**
* Transforms the normal parameter by this Matrix4d and places the value
* into normalOut. The fourth element of the normal is assumed to be zero.
* @param normal the input normal to be transformed.
* @param normalOut the transformed normal
*/
public final void transform(Vector3d normal, Vector3d normalOut)
{
double x,y;
x = m00*normal.x + m01*normal.y + m02*normal.z;
y = m10*normal.x + m11*normal.y + m12*normal.z;
normalOut.z = m20*normal.x + m21*normal.y + m22*normal.z;
normalOut.x = x;
normalOut.y = y;
}
/**
* Transforms the normal parameter by this transform and places the value
* back into normal. The fourth element of the normal is assumed to be zero.
* @param normal the input normal to be transformed.
*/
public final void transform(Vector3d normal)
{
double x, y;
x = m00*normal.x + m01*normal.y + m02*normal.z;
y = m10*normal.x + m11*normal.y + m12*normal.z;
normal.z = m20*normal.x + m21*normal.y + m22*normal.z;
normal.x = x;
normal.y = y;
}
/**
* Transforms the normal parameter by this Matrix4d and places the value
* into normalOut. The fourth element of the normal is assumed to be zero.
* @param normal the input normal to be transformed.
* @param normalOut the transformed normal
*/
public final void transform(Vector3f normal, Vector3f normalOut)
{
float x,y;
x = (float) (m00*normal.x + m01*normal.y + m02*normal.z);
y = (float) (m10*normal.x + m11*normal.y + m12*normal.z);
normalOut.z = (float) (m20*normal.x + m21*normal.y + m22*normal.z);
normalOut.x = x;
normalOut.y = y;
}
/**
* Transforms the normal parameter by this transform and places the value
* back into normal. The fourth element of the normal is assumed to be zero.
* @param normal the input normal to be transformed.
*/
public final void transform(Vector3f normal)
{
float x, y;
x = (float) (m00*normal.x + m01*normal.y + m02*normal.z);
y = (float) (m10*normal.x + m11*normal.y + m12*normal.z);
normal.z = (float) (m20*normal.x + m21*normal.y + m22*normal.z);
normal.x = x;
normal.y = y;
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix values in the double precision Matrix3d argument; the other
* elements of this matrix are unchanged; a singular value
* decomposition is performed on this object's upper 3x3 matrix to
* factor out the scale, then this object's upper 3x3 matrix components
* are replaced by the passed rotation components,
* and then the scale is reapplied to the rotational components.
* @param m1 double precision 3x3 matrix
*/
public final void setRotation( Matrix3d m1){
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m00 = m1.m00*tmp_scale[0];
m01 = m1.m01*tmp_scale[1];
m02 = m1.m02*tmp_scale[2];
m10 = m1.m10*tmp_scale[0];
m11 = m1.m11*tmp_scale[1];
m12 = m1.m12*tmp_scale[2];
m20 = m1.m20*tmp_scale[0];
m21 = m1.m21*tmp_scale[1];
m22 = m1.m22*tmp_scale[2];
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix values in the single precision Matrix3f argument; the other
* elements of this matrix are unchanged; a singular value
* decomposition is performed on this object's upper 3x3 matrix to
* factor out the scale, then this object's upper 3x3 matrix components
* are replaced by the passed rotation components,
* and then the scale is reapplied to the rotational components.
* @param m1 single precision 3x3 matrix
*/
public final void setRotation( Matrix3f m1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m00 = m1.m00*tmp_scale[0];
m01 = m1.m01*tmp_scale[1];
m02 = m1.m02*tmp_scale[2];
m10 = m1.m10*tmp_scale[0];
m11 = m1.m11*tmp_scale[1];
m12 = m1.m12*tmp_scale[2];
m20 = m1.m20*tmp_scale[0];
m21 = m1.m21*tmp_scale[1];
m22 = m1.m22*tmp_scale[2];
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix equivalent values of the quaternion argument; the other
* elements of this matrix are unchanged; a singular value
* decomposition is performed on this object's upper 3x3 matrix to
* factor out the scale, then this object's upper 3x3 matrix components
* are replaced by the matrix equivalent of the quaternion,
* and then the scale is reapplied to the rotational components.
* @param q1 the quaternion that specifies the rotation
*/
public final void setRotation(Quat4f q1){
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m00 = (1.0 - 2.0f*q1.y*q1.y - 2.0f*q1.z*q1.z)*tmp_scale[0];
m10 = (2.0*(q1.x*q1.y + q1.w*q1.z))*tmp_scale[0];
m20 = (2.0*(q1.x*q1.z - q1.w*q1.y))*tmp_scale[0];
m01 = (2.0*(q1.x*q1.y - q1.w*q1.z))*tmp_scale[1];
m11 = (1.0 - 2.0f*q1.x*q1.x - 2.0f*q1.z*q1.z)*tmp_scale[1];
m21 = (2.0*(q1.y*q1.z + q1.w*q1.x))*tmp_scale[1];
m02 = (2.0*(q1.x*q1.z + q1.w*q1.y))*tmp_scale[2];
m12 = (2.0*(q1.y*q1.z - q1.w*q1.x))*tmp_scale[2];
m22 = (1.0 - 2.0f*q1.x*q1.x - 2.0f*q1.y*q1.y)*tmp_scale[2];
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix equivalent values of the quaternion argument; the other
* elements of this matrix are unchanged; a singular value
* decomposition is performed on this object's upper 3x3 matrix to
* factor out the scale, then this object's upper 3x3 matrix components
* are replaced by the matrix equivalent of the quaternion,
* and then the scale is reapplied to the rotational components.
* @param q1 the quaternion that specifies the rotation
*/
public final void setRotation(Quat4d q1){
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
m00 = (1.0 - 2.0f*q1.y*q1.y - 2.0f*q1.z*q1.z)*tmp_scale[0];
m10 = (2.0*(q1.x*q1.y + q1.w*q1.z))*tmp_scale[0];
m20 = (2.0*(q1.x*q1.z - q1.w*q1.y))*tmp_scale[0];
m01 = (2.0*(q1.x*q1.y - q1.w*q1.z))*tmp_scale[1];
m11 = (1.0 - 2.0f*q1.x*q1.x - 2.0f*q1.z*q1.z)*tmp_scale[1];
m21 = (2.0*(q1.y*q1.z + q1.w*q1.x))*tmp_scale[1];
m02 = (2.0*(q1.x*q1.z + q1.w*q1.y))*tmp_scale[2];
m12 = (2.0*(q1.y*q1.z - q1.w*q1.x))*tmp_scale[2];
m22 = (1.0 - 2.0f*q1.x*q1.x - 2.0f*q1.y*q1.y)*tmp_scale[2];
}
/**
* Sets the rotational component (upper 3x3) of this matrix to the
* matrix equivalent values of the axis-angle argument; the other
* elements of this matrix are unchanged; a singular value
* decomposition is performed on this object's upper 3x3 matrix to
* factor out the scale, then this object's upper 3x3 matrix components
* are replaced by the matrix equivalent of the axis-angle,
* and then the scale is reapplied to the rotational components.
* @param a1 the axis-angle to be converted (x, y, z, angle)
*/
public final void setRotation(AxisAngle4d a1)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
double mag = 1.0/Math.sqrt( a1.x*a1.x + a1.y*a1.y + a1.z*a1.z);
double ax = a1.x*mag;
double ay = a1.y*mag;
double az = a1.z*mag;
double sinTheta = Math.sin(a1.angle);
double cosTheta = Math.cos(a1.angle);
double t = 1.0 - cosTheta;
double xz = a1.x * a1.z;
double xy = a1.x * a1.y;
double yz = a1.y * a1.z;
m00 = (t * ax * ax + cosTheta)*tmp_scale[0];
m01 = (t * xy - sinTheta * az)*tmp_scale[1];
m02 = (t * xz + sinTheta * ay)*tmp_scale[2];
m10 = (t * xy + sinTheta * az)*tmp_scale[0];
m11 = (t * ay * ay + cosTheta)*tmp_scale[1];
m12 = (t * yz - sinTheta * ax)*tmp_scale[2];
m20 = (t * xz - sinTheta * ay)*tmp_scale[0];
m21 = (t * yz + sinTheta * ax)*tmp_scale[1];
m22 = (t * az * az + cosTheta)*tmp_scale[2];
}
/**
* Sets this matrix to all zeros.
*/
public final void setZero()
{
m00 = 0.0;
m01 = 0.0;
m02 = 0.0;
m03 = 0.0;
m10 = 0.0;
m11 = 0.0;
m12 = 0.0;
m13 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 0.0;
m23 = 0.0;
m30 = 0.0;
m31 = 0.0;
m32 = 0.0;
m33 = 0.0;
}
/**
* Negates the value of this matrix: this = -this.
*/
public final void negate()
{
m00 = -m00;
m01 = -m01;
m02 = -m02;
m03 = -m03;
m10 = -m10;
m11 = -m11;
m12 = -m12;
m13 = -m13;
m20 = -m20;
m21 = -m21;
m22 = -m22;
m23 = -m23;
m30 = -m30;
m31 = -m31;
m32 = -m32;
m33 = -m33;
}
/**
* Sets the value of this matrix equal to the negation of
* of the Matrix4d parameter.
* @param m1 the source matrix
*/
public final void negate(Matrix4d m1)
{
this.m00 = -m1.m00;
this.m01 = -m1.m01;
this.m02 = -m1.m02;
this.m03 = -m1.m03;
this.m10 = -m1.m10;
this.m11 = -m1.m11;
this.m12 = -m1.m12;
this.m13 = -m1.m13;
this.m20 = -m1.m20;
this.m21 = -m1.m21;
this.m22 = -m1.m22;
this.m23 = -m1.m23;
this.m30 = -m1.m30;
this.m31 = -m1.m31;
this.m32 = -m1.m32;
this.m33 = -m1.m33;
}
private final void getScaleRotate(double scales[], double rots[]) {
double[] tmp = new double[9]; // scratch matrix
tmp[0] = m00;
tmp[1] = m01;
tmp[2] = m02;
tmp[3] = m10;
tmp[4] = m11;
tmp[5] = m12;
tmp[6] = m20;
tmp[7] = m21;
tmp[8] = m22;
Matrix3d.compute_svd( tmp, scales, rots);
return;
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
Matrix4d m1 = null;
try {
m1 = (Matrix4d)super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
return m1;
}
/**
* Get the first matrix element in the first row.
*
* @return Returns the m00.
*
* @since vecmath 1.5
*/
public final double getM00() {
return m00;
}
/**
* Set the first matrix element in the first row.
*
* @param m00 The m00 to set.
*
*
* @since vecmath 1.5
*/
public final void setM00(double m00) {
this.m00 = m00;
}
/**
* Get the second matrix element in the first row.
*
* @return Returns the m01.
*
* @since vecmath 1.5
*/
public final double getM01() {
return m01;
}
/**
* Set the second matrix element in the first row.
*
* @param m01 The m01 to set.
*
* @since vecmath 1.5
*/
public final void setM01(double m01) {
this.m01 = m01;
}
/**
* Get the third matrix element in the first row.
*
* @return Returns the m02.
*
* @since vecmath 1.5
*/
public final double getM02() {
return m02;
}
/**
* Set the third matrix element in the first row.
*
* @param m02 The m02 to set.
*
* @since vecmath 1.5
*/
public final void setM02(double m02) {
this.m02 = m02;
}
/**
* Get first matrix element in the second row.
*
* @return Returns the m10.
*
* @since vecmath 1.5
*/
public final double getM10() {
return m10;
}
/**
* Set first matrix element in the second row.
*
* @param m10 The m10 to set.
*
* @since vecmath 1.5
*/
public final void setM10(double m10) {
this.m10 = m10;
}
/**
* Get second matrix element in the second row.
*
* @return Returns the m11.
*
* @since vecmath 1.5
*/
public final double getM11() {
return m11;
}
/**
* Set the second matrix element in the second row.
*
* @param m11 The m11 to set.
*
* @since vecmath 1.5
*/
public final void setM11(double m11) {
this.m11 = m11;
}
/**
* Get the third matrix element in the second row.
*
* @return Returns the m12.
*
* @since vecmath 1.5
*/
public final double getM12() {
return m12;
}
/**
* Set the third matrix element in the second row.
*
* @param m12 The m12 to set.
*
*
* @since vecmath 1.5
*/
public final void setM12(double m12) {
this.m12 = m12;
}
/**
* Get the first matrix element in the third row.
*
* @return Returns the m20.
*
* @since vecmath 1.5
*/
public final double getM20() {
return m20;
}
/**
* Set the first matrix element in the third row.
*
* @param m20 The m20 to set.
*
* @since vecmath 1.5
*/
public final void setM20(double m20) {
this.m20 = m20;
}
/**
* Get the second matrix element in the third row.
*
* @return Returns the m21.
*
* @since vecmath 1.5
*/
public final double getM21() {
return m21;
}
/**
* Set the second matrix element in the third row.
*
* @param m21 The m21 to set.
*
* @since vecmath 1.5
*/
public final void setM21(double m21) {
this.m21 = m21;
}
/**
* Get the third matrix element in the third row.
*
* @return Returns the m22.
*
* @since vecmath 1.5
*/
public final double getM22() {
return m22;
}
/**
* Set the third matrix element in the third row.
*
* @param m22 The m22 to set.
*
* @since vecmath 1.5
*/
public final void setM22(double m22) {
this.m22 = m22;
}
/**
* Get the fourth element of the first row.
*
* @return Returns the m03.
*
* @since vecmath 1.5
*/
public final double getM03() {
return m03;
}
/**
* Set the fourth element of the first row.
*
* @param m03 The m03 to set.
*
* @since vecmath 1.5
*/
public final void setM03(double m03) {
this.m03 = m03;
}
/**
* Get the fourth element of the second row.
*
* @return Returns the m13.
*
* @since vecmath 1.5
*/
public final double getM13() {
return m13;
}
/**
* Set the fourth element of the second row.
*
* @param m13 The m13 to set.
*
* @since vecmath 1.5
*/
public final void setM13(double m13) {
this.m13 = m13;
}
/**
* Get the fourth element of the third row.
*
* @return Returns the m23.
*
* @since vecmath 1.5
*/
public final double getM23() {
return m23;
}
/**
* Set the fourth element of the third row.
*
* @param m23 The m23 to set.
*
* @since vecmath 1.5
*/
public final void setM23(double m23) {
this.m23 = m23;
}
/**
* Get the first element of the fourth row.
*
* @return Returns the m30.
*
* @since vecmath 1.5
*/
public final double getM30() {
return m30;
}
/**
* Set the first element of the fourth row.
*
* @param m30 The m30 to set.
*
* @since vecmath 1.5
*/
public final void setM30(double m30) {
this.m30 = m30;
}
/**
* Get the second element of the fourth row.
*
* @return Returns the m31.
*
* @since vecmath 1.5
*/
public final double getM31() {
return m31;
}
/**
* Set the second element of the fourth row.
*
* @param m31 The m31 to set.
*
* @since vecmath 1.5
*/
public final void setM31(double m31) {
this.m31 = m31;
}
/**
* Get the third element of the fourth row.
*
* @return Returns the m32.
*
*
* @since vecmath 1.5
*/
public final double getM32() {
return m32;
}
/**
* Set the third element of the fourth row.
*
* @param m32 The m32 to set.
*
* @since vecmath 1.5
*/
public final void setM32(double m32) {
this.m32 = m32;
}
/**
* Get the fourth element of the fourth row.
*
* @return Returns the m33.
*
* @since vecmath 1.5
*/
public final double getM33() {
return m33;
}
/**
* Set the fourth element of the fourth row.
*
* @param m33 The m33 to set.
*
* @since vecmath 1.5
*/
public final void setM33(double m33) {
this.m33 = m33;
}
}
source-cvs/vecmath/src/javax/vecmath/AxisAngle4d.java 0000644 0001750 0001750 00000036574 10761613452 022173 0 ustar jonny jonny /*
* $RCSfile: AxisAngle4d.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.9 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
/**
* A four-element axis angle represented by double-precision floating point
* x,y,z,angle components. An axis angle is a rotation of angle (radians)
* about the vector (x,y,z).
*
*/
public class AxisAngle4d implements java.io.Serializable, Cloneable {
// Compatible with 1.1
static final long serialVersionUID = 3644296204459140589L;
/**
* The x coordinate.
*/
public double x;
/**
* The y coordinate.
*/
public double y;
/**
* The z coordinate.
*/
public double z;
/**
* The angle of rotation in radians.
*/
public double angle;
// Fixed to issue 538
final static double EPS = 1.0e-12;
/**
* Constructs and initializes an AxisAngle4d from the specified
* x, y, z, and angle.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param angle the angle of rotation in radians
*/
public AxisAngle4d(double x, double y, double z, double angle)
{
this.x = x;
this.y = y;
this.z = z;
this.angle = angle;
}
/**
* Constructs and initializes an AxisAngle4d from the components
* contained in the array.
* @param a the array of length 4 containing x,y,z,angle in order
*/
public AxisAngle4d(double[] a)
{
this.x = a[0];
this.y = a[1];
this.z = a[2];
this.angle = a[3];
}
/**
* Constructs and initializes an AxisAngle4d from the specified AxisAngle4d.
* @param a1 the AxisAngle4d containing the initialization x y z angle data
*/
public AxisAngle4d(AxisAngle4d a1)
{
this.x = a1.x;
this.y = a1.y;
this.z = a1.z;
this.angle = a1.angle;
}
/**
* Constructs and initializes an AxisAngle4d from the specified
* AxisAngle4f.
* @param a1 the AxisAngle4f containing the initialization x y z angle data
*/
public AxisAngle4d(AxisAngle4f a1)
{
this.x = a1.x;
this.y = a1.y;
this.z = a1.z;
this.angle = a1.angle;
}
/**
* Constructs and initializes an AxisAngle4d from the specified
* axis and angle.
* @param axis the axis
* @param angle the angle of rotation in radian
*
* @since vecmath 1.2
*/
public AxisAngle4d(Vector3d axis, double angle) {
this.x = axis.x;
this.y = axis.y;
this.z = axis.z;
this.angle = angle;
}
/**
* Constructs and initializes an AxisAngle4d to (0,0,1,0).
*/
public AxisAngle4d()
{
this.x = 0.0;
this.y = 0.0;
this.z = 1.0;
this.angle = 0.0;
}
/**
* Sets the value of this axis angle to the specified x,y,z,angle.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param angle the angle of rotation in radians
*/
public final void set(double x, double y, double z, double angle)
{
this.x = x;
this.y = y;
this.z = z;
this.angle = angle;
}
/**
* Sets the value of this axis angle to the specified x,y,z,angle.
* @param a the array of length 4 containing x,y,z,angle in order
*/
public final void set(double[] a)
{
this.x = a[0];
this.y = a[1];
this.z = a[2];
this.angle = a[3];
}
/**
* Sets the value of this axis angle to the value of axis angle a1.
* @param a1 the axis angle to be copied
*/
public final void set(AxisAngle4d a1)
{
this.x = a1.x;
this.y = a1.y;
this.z = a1.z;
this.angle = a1.angle;
}
/**
* Sets the value of this axis angle to the value of axis angle a1.
* @param a1 the axis angle to be copied
*/
public final void set(AxisAngle4f a1)
{
this.x = a1.x;
this.y = a1.y;
this.z = a1.z;
this.angle = a1.angle;
}
/**
* Sets the value of this AxisAngle4d to the specified
* axis and angle.
* @param axis the axis
* @param angle the angle of rotation in radians
*
* @since vecmath 1.2
*/
public final void set(Vector3d axis, double angle) {
this.x = axis.x;
this.y = axis.y;
this.z = axis.z;
this.angle = angle;
}
/**
* Gets the value of this axis angle and places it into the array a of
* length four in x,y,z,angle order.
* @param a the array of length four
*/
public final void get(double[] a)
{
a[0] = this.x;
a[1] = this.y;
a[2] = this.z;
a[3] = this.angle;
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4d is set to an angle of 0 about an axis of (0,1,0).
*
* @param m1 the matrix4f
*/
public final void set(Matrix4f m1)
{
Matrix3d m3d = new Matrix3d();
m1.get(m3d);
x = (float)(m3d.m21 - m3d.m12);
y = (float)(m3d.m02 - m3d.m20);
z = (float)(m3d.m10 - m3d.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS ) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m3d.m00 + m3d.m11 + m3d.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = x*invMag;
y = y*invMag;
z = z*invMag;
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4d is set to an angle of 0 about an axis of (0,1,0).
*
* @param m1 the matrix4d
*/
public final void set(Matrix4d m1)
{
Matrix3d m3d = new Matrix3d();
m1.get(m3d);
x = (float)(m3d.m21 - m3d.m12);
y = (float)(m3d.m02 - m3d.m20);
z = (float)(m3d.m10 - m3d.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS ) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m3d.m00 + m3d.m11 + m3d.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = x*invMag;
y = y*invMag;
z = z*invMag;
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4d is set to an angle of 0 about an axis of (0,1,0).
* @param m1 the matrix3f
*/
public final void set(Matrix3f m1)
{
x = (float)(m1.m21 - m1.m12);
y = (float)(m1.m02 - m1.m20);
z = (float)(m1.m10 - m1.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS ) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m1.m00 + m1.m11 + m1.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = x*invMag;
y = y*invMag;
z = z*invMag;
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4d is set to an angle of 0 about an axis of (0,1,0).
* @param m1 the matrix3d
*/
public final void set(Matrix3d m1)
{
x = (float)(m1.m21 - m1.m12);
y = (float)(m1.m02 - m1.m20);
z = (float)(m1.m10 - m1.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS ) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m1.m00 + m1.m11 + m1.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = x*invMag;
y = y*invMag;
z = z*invMag;
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational equivalent
* of the passed quaternion.
* If the specified quaternion has no rotational component, the value
* of this AxisAngle4d is set to an angle of 0 about an axis of (0,1,0).
* @param q1 the Quat4f
*/
public final void set(Quat4f q1)
{
double mag = q1.x*q1.x + q1.y*q1.y + q1.z*q1.z;
if( mag > EPS ) {
mag = Math.sqrt(mag);
double invMag = 1.0/mag;
x = q1.x*invMag;
y = q1.y*invMag;
z = q1.z*invMag;
angle = 2.0*Math.atan2(mag, q1.w);
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational equivalent
* of the passed quaternion.
* If the specified quaternion has no rotational component, the value
* of this AxisAngle4d is set to an angle of 0 about an axis of (0,1,0).
* @param q1 the Quat4d
*/
public final void set(Quat4d q1)
{
double mag = q1.x*q1.x + q1.y*q1.y + q1.z*q1.z;
if ( mag > EPS ) {
mag = Math.sqrt(mag);
double invMag = 1.0/mag;
x = q1.x*invMag;
y = q1.y*invMag;
z = q1.z*invMag;
angle = 2.0*Math.atan2(mag, q1.w);
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0f;
}
}
/**
* Returns a string that contains the values of this AxisAngle4d.
* The form is (x,y,z,angle).
* @return the String representation
*/
public String toString() {
return "(" + this.x + ", " + this.y + ", " + this.z + ", " + this.angle + ")";
}
/**
* Returns true if all of the data members of AxisAngle4d a1 are
* equal to the corresponding data members in this AxisAngle4d.
* @param a1 the axis-angle with which the comparison is made
* @return true or false
*/
public boolean equals(AxisAngle4d a1)
{
try {
return(this.x == a1.x && this.y == a1.y && this.z == a1.z
&& this.angle == a1.angle);
}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the Object o1 is of type AxisAngle4d and all of the
* data members of o1 are equal to the corresponding data members in
* this AxisAngle4d.
* @param o1 the object with which the comparison is made
* @return true or false
*/
public boolean equals(Object o1)
{
try {
AxisAngle4d a2 = (AxisAngle4d) o1;
return(this.x == a2.x && this.y == a2.y && this.z == a2.z
&& this.angle == a2.angle);
}
catch (NullPointerException e2) {return false;}
catch (ClassCastException e1) {return false;}
}
/**
* Returns true if the L-infinite distance between this axis-angle
* and axis-angle a1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to
* MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(angle1-angle2)].
* @param a1 the axis-angle to be compared to this axis-angle
* @param epsilon the threshold value
*/
public boolean epsilonEquals(AxisAngle4d a1, double epsilon)
{
double diff;
diff = x - a1.x;
if((diff<0?-diff:diff) > epsilon) return false;
diff = y - a1.y;
if((diff<0?-diff:diff) > epsilon) return false;
diff = z - a1.z;
if((diff<0?-diff:diff) > epsilon) return false;
diff = angle - a1.angle;
if((diff<0?-diff:diff) > epsilon) return false;
return true;
}
/**
* Returns a hash code value based on the data values in this
* object. Two different AxisAngle4d objects with identical data values
* (i.e., AxisAngle4d.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + VecMathUtil.doubleToLongBits(x);
bits = 31L * bits + VecMathUtil.doubleToLongBits(y);
bits = 31L * bits + VecMathUtil.doubleToLongBits(z);
bits = 31L * bits + VecMathUtil.doubleToLongBits(angle);
return (int) (bits ^ (bits >> 32));
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the axis angle, in radians. Provides 3D vector mathematics classes. To
build the vecmath package, you must first checkout the vecmath
CVS
repository. For example, run
the cvs checkout command as follows: After you have downloaded the CVS repository, read the
README-FIRST.txt file, then read and follow the
instructions in the README-build.html
file. Go to the "CVS client setup"
page for instructions on how to access the vecmath source code from
CVS. Click on the "Version Control -
CVS"
link to browse the vecmath source code. Automated CVS change
messages are sent to the cvs 'at'
vecmath.dev.java.net
list list. Click here to
subscribe to this list. This page is obsolete. Click here
to go the Java 3D Roadmap page of the Java 3D Wiki. This page is obsolete. Click here
to go the Java 3D Roadmap page of the Java 3D Wiki. This project contains the source code
for the 3D vector math package, Related projects include: j3d-core
(the core 3D pacakge),
j3d-core-utils
(the 3D core utilities), and
j3d-examples
(the 3D example programs). Developers should refer to the CVS download
and build
instructions for information on downloading the source code and
building vecmath. For all other project
information, including contributing to the 3D projects and reporting
issues,
please go to the parent java3d
project. NOTE: The issue Tracker in this vecmath subproject cannot be used
to file or track issues. Please use the Issue Tracker
in the parent java3d
project
to track issues (bugs, feature requests, etc.) for
vecmath and other 3D sub-projects. The source code for the length elements (i.e., vector.length >=
* length. The length of this new GVector is set to
* the specified length.
* @param vector The array from which the values will be copied.
* @param length The number of values copied from the array.
*/
public GVector(double vector[], int length) {
int i;
this.length = length;
values = new double [length];
for(i=0;i
* An axis angle is a rotation angle about the vector (x,y,z).
*
* @return the angle, in radians.
*
* @since vecmath 1.5
*/
public final double getAngle() {
return angle;
}
/**
* Set the axis angle, in radians.
* An axis angle is a rotation angle about the vector (x,y,z).
*
* @param angle The angle to set, in radians.
*
* @since vecmath 1.5
*/
public final void setAngle(double angle) {
this.angle = angle;
}
/**
* Get value of x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public double getX() {
return x;
}
/**
* Set a new value for x coordinate.
*
* @param x the x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(double x) {
this.x = x;
}
/**
* Get value of y coordinate.
*
* @return the y coordinate.
*
* @since vecmath 1.5
*/
public final double getY() {
return y;
}
/**
* Set a new value for y coordinate.
*
* @param y the y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(double y) {
this.y = y;
}
/**
* Get value of z coordinate.
*
* @return the z coordinate.
*
* @since vecmath 1.5
*/
public double getZ() {
return z;
}
/**
* Set a new value for z coordinate.
*
* @param z the z coordinate.
*
* @since vecmath 1.5
*/
public final void setZ(double z) {
this.z = z;
}
}
source-cvs/vecmath/src/javax/vecmath/VecMathI18N.java 0000644 0001750 0001750 00000003240 10761613453 022000 0 ustar jonny jonny /*
* $RCSfile: VecMathI18N.java,v $
*
* Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.io.*;
import java.util.*;
class VecMathI18N {
static String getString(String key) {
String s;
try {
s = (String) ResourceBundle.getBundle("javax.vecmath.ExceptionStrings").getString(key);
}
catch (MissingResourceException e) {
System.err.println("VecMathI18N: Error looking up: " + key);
s = key;
}
return s;
}
}
source-cvs/vecmath/src/javax/vecmath/Tuple2d.java 0000644 0001750 0001750 00000034206 10761613452 021375 0 ustar jonny jonny /*
* $RCSfile: Tuple2d.java,v $
*
* Copyright 1998-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.8 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A generic 2-element tuple that is represented by double-precision
* floating point x,y coordinates.
*
*/
public abstract class Tuple2d implements java.io.Serializable, Cloneable {
static final long serialVersionUID = 6205762482756093838L;
/**
* The x coordinate.
*/
public double x;
/**
* The y coordinate.
*/
public double y;
/**
* Constructs and initializes a Tuple2d from the specified xy coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public Tuple2d(double x, double y)
{
this.x = x;
this.y = y;
}
/**
* Constructs and initializes a Tuple2d from the specified array.
* @param t the array of length 2 containing xy in order
*/
public Tuple2d(double[] t)
{
this.x = t[0];
this.y = t[1];
}
/**
* Constructs and initializes a Tuple2d from the specified Tuple2d.
* @param t1 the Tuple2d containing the initialization x y data
*/
public Tuple2d(Tuple2d t1)
{
this.x = t1.x;
this.y = t1.y;
}
/**
* Constructs and initializes a Tuple2d from the specified Tuple2f.
* @param t1 the Tuple2f containing the initialization x y data
*/
public Tuple2d(Tuple2f t1)
{
this.x = (double) t1.x;
this.y = (double) t1.y;
}
/**
* Constructs and initializes a Tuple2d to (0,0).
*/
public Tuple2d()
{
this.x = 0.0;
this.y = 0.0;
}
/**
* Sets the value of this tuple to the specified xy coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public final void set(double x, double y)
{
this.x = x;
this.y = y;
}
/**
* Sets the value of this tuple from the 2 values specified in
* the array.
* @param t the array of length 2 containing xy in order
*/
public final void set(double[] t)
{
this.x = t[0];
this.y = t[1];
}
/**
* Sets the value of this tuple to the value of the Tuple2d argument.
* @param t1 the tuple to be copied
*/
public final void set(Tuple2d t1)
{
this.x = t1.x;
this.y = t1.y;
}
/**
* Sets the value of this tuple to the value of Tuple2f t1.
* @param t1 the tuple to be copied
*/
public final void set(Tuple2f t1)
{
this.x = (double) t1.x;
this.y = (double) t1.y;
}
/**
* Copies the value of the elements of this tuple into the array t.
* @param t the array that will contain the values of the vector
*/
public final void get(double[] t)
{
t[0] = this.x;
t[1] = this.y;
}
/**
* Sets the value of this tuple to the vector sum of tuples t1 and t2.
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void add(Tuple2d t1, Tuple2d t2)
{
this.x = t1.x + t2.x;
this.y = t1.y + t2.y;
}
/**
* Sets the value of this tuple to the vector sum of itself and tuple t1.
* @param t1 the other tuple
*/
public final void add(Tuple2d t1)
{
this.x += t1.x;
this.y += t1.y;
}
/**
* Sets the value of this tuple to the vector difference of
* tuple t1 and t2 (this = t1 - t2).
* @param t1 the first tuple
* @param t2 the second tuple
*/
public final void sub(Tuple2d t1, Tuple2d t2)
{
this.x = t1.x - t2.x;
this.y = t1.y - t2.y;
}
/**
* Sets the value of this tuple to the vector difference of
* itself and tuple t1 (this = this - t1).
* @param t1 the other vector
*/
public final void sub(Tuple2d t1)
{
this.x -= t1.x;
this.y -= t1.y;
}
/**
* Sets the value of this tuple to the negation of tuple t1.
* @param t1 the source vector
*/
public final void negate(Tuple2d t1)
{
this.x = -t1.x;
this.y = -t1.y;
}
/**
* Negates the value of this vector in place.
*/
public final void negate()
{
this.x = -this.x;
this.y = -this.y;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1.
* @param s the scalar value
* @param t1 the source tuple
*/
public final void scale(double s, Tuple2d t1)
{
this.x = s*t1.x;
this.y = s*t1.y;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself.
* @param s the scalar value
*/
public final void scale(double s)
{
this.x *= s;
this.y *= s;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of tuple t1 and then adds tuple t2 (this = s*t1 + t2).
* @param s the scalar value
* @param t1 the tuple to be multipled
* @param t2 the tuple to be added
*/
public final void scaleAdd(double s, Tuple2d t1, Tuple2d t2)
{
this.x = s*t1.x + t2.x;
this.y = s*t1.y + t2.y;
}
/**
* Sets the value of this tuple to the scalar multiplication
* of itself and then adds tuple t1 (this = s*this + t1).
* @param s the scalar value
* @param t1 the tuple to be added
*/
public final void scaleAdd(double s, Tuple2d t1)
{
this.x = s*this.x + t1.x;
this.y = s*this.y + t1.y;
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple2d objects with identical data values
* (i.e., Tuple2d.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + VecMathUtil.doubleToLongBits(x);
bits = 31L * bits + VecMathUtil.doubleToLongBits(y);
return (int) (bits ^ (bits >> 32));
}
/**
* Returns true if all of the data members of Tuple2d t1 are
* equal to the corresponding data members in this Tuple2d.
* @param t1 the vector with which the comparison is made
* @return true or false
*/
public boolean equals(Tuple2d t1)
{
try {
return(this.x == t1.x && this.y == t1.y);
}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the Object t1 is of type Tuple2d and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple2d.
* @param t1 the object with which the comparison is made
* @return true or false
*/
public boolean equals(Object t1)
{
try {
Tuple2d t2 = (Tuple2d) t1;
return(this.x == t2.x && this.y == t2.y);
}
catch (NullPointerException e2) {return false;}
catch (ClassCastException e1) {return false;}
}
/**
* Returns true if the L-infinite distance between this tuple
* and tuple t1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to MAX[abs(x1-x2), abs(y1-y2)].
* @param t1 the tuple to be compared to this tuple
* @param epsilon the threshold value
* @return true or false
*/
public boolean epsilonEquals(Tuple2d t1, double epsilon)
{
double diff;
diff = x - t1.x;
if(Double.isNaN(diff)) return false;
if((diff<0?-diff:diff) > epsilon) return false;
diff = y - t1.y;
if(Double.isNaN(diff)) return false;
if((diff<0?-diff:diff) > epsilon) return false;
return true;
}
/**
* Returns a string that contains the values of this Tuple2d.
* The form is (x,y).
* @return the String representation
*/
public String toString()
{
return("(" + this.x + ", " + this.y + ")");
}
/**
* Clamps the tuple parameter to the range [low, high] and
* places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clamp(double min, double max, Tuple2d t)
{
if( t.x > max ) {
x = max;
} else if( t.x < min ){
x = min;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else if( t.y < min ){
y = min;
} else {
y = t.y;
}
}
/**
* Clamps the minimum value of the tuple parameter to the min
* parameter and places the values into this tuple.
* @param min the lowest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMin(double min, Tuple2d t)
{
if( t.x < min ) {
x = min;
} else {
x = t.x;
}
if( t.y < min ) {
y = min;
} else {
y = t.y;
}
}
/**
* Clamps the maximum value of the tuple parameter to the max
* parameter and places the values into this tuple.
* @param max the highest value in the tuple after clamping
* @param t the source tuple, which will not be modified
*/
public final void clampMax(double max, Tuple2d t)
{
if( t.x > max ) {
x = max;
} else {
x = t.x;
}
if( t.y > max ) {
y = max;
} else {
y = t.y;
}
}
/**
* Sets each component of the tuple parameter to its absolute
* value and places the modified values into this tuple.
* @param t the source tuple, which will not be modified
*/
public final void absolute(Tuple2d t)
{
x = Math.abs(t.x);
y = Math.abs(t.y);
}
/**
* Clamps this tuple to the range [low, high].
* @param min the lowest value in this tuple after clamping
* @param max the highest value in this tuple after clamping
*/
public final void clamp(double min, double max)
{
if( x > max ) {
x = max;
} else if( x < min ){
x = min;
}
if( y > max ) {
y = max;
} else if( y < min ){
y = min;
}
}
/**
* Clamps the minimum value of this tuple to the min parameter.
* @param min the lowest value in this tuple after clamping
*/
public final void clampMin(double min)
{
if( x < min ) x=min;
if( y < min ) y=min;
}
/**
* Clamps the maximum value of this tuple to the max parameter.
* @param max the highest value in the tuple after clamping
*/
public final void clampMax(double max)
{
if( x > max ) x=max;
if( y > max ) y=max;
}
/**
* Sets each component of this tuple to its absolute value.
*/
public final void absolute()
{
x = Math.abs(x);
y = Math.abs(y);
}
/**
* Linearly interpolates between tuples t1 and t2 and places the
* result into this tuple: this = (1-alpha)*t1 + alpha*t2.
* @param t1 the first tuple
* @param t2 the second tuple
* @param alpha the alpha interpolation parameter
*/
public final void interpolate(Tuple2d t1, Tuple2d t2, double alpha)
{
this.x = (1-alpha)*t1.x + alpha*t2.x;
this.y = (1-alpha)*t1.y + alpha*t2.y;
}
/**
* Linearly interpolates between this tuple and tuple t1 and
* places the result into this tuple: this = (1-alpha)*this + alpha*t1.
* @param t1 the first tuple
* @param alpha the alpha interpolation parameter
*/
public final void interpolate(Tuple2d t1, double alpha)
{
this.x = (1-alpha)*this.x + alpha*t1.x;
this.y = (1-alpha)*this.y + alpha*t1.y;
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public final double getX() {
return x;
}
/**
* Set the x coordinate.
*
* @param x value to x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(double x) {
this.x = x;
}
/**
* Get the y coordinate.
*
* @return the y coordinate.
*
* @since vecmath 1.5
*/
public final double getY() {
return y;
}
/**
* Set the y coordinate.
*
* @param y value to y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(double y) {
this.y = y;
}
}
source-cvs/vecmath/src/javax/vecmath/Tuple3b.java 0000644 0001750 0001750 00000017316 10761613453 021400 0 ustar jonny jonny /*
* $RCSfile: Tuple3b.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.7 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A three byte tuple. Note that Java defines a byte as a signed integer
* in the range [-128, 127]. However, colors are more typically
* represented by values in the range [0, 255]. Java 3D recognizes this
* and, in those cases where Tuple3b is used to represent color, treats
* the bytes as if the range were [0, 255]---in other words, as if the
* bytes were unsigned.
* Values greater than 127 can be assigned to a byte variable using a
* type cast. For example:
* byteVariable = (byte) intValue; // intValue can be > 127
* If intValue is greater than 127, then byteVariable will be negative. The
* correct value will be extracted when it is used (by masking off the upper
* bits).
*/
public abstract class Tuple3b implements java.io.Serializable, Cloneable {
static final long serialVersionUID = -483782685323607044L;
/**
* The first value.
*/
public byte x;
/**
* The second value.
*/
public byte y;
/**
* The third value.
*/
public byte z;
/**
* Constructs and initializes a Tuple3b from the specified three values.
* @param b1 the first value
* @param b2 the second value
* @param b3 the third value
*/
public Tuple3b(byte b1, byte b2, byte b3)
{
this.x = b1;
this.y = b2;
this.z = b3;
}
/**
* Constructs and initializes a Tuple3b from input array of length 3.
* @param t the array of length 3 containing b1 b2 b3 in order
*/
public Tuple3b(byte[] t)
{
this.x = t[0];
this.y = t[1];
this.z = t[2];
}
/**
* Constructs and initializes a Tuple3b from the specified Tuple3b.
* @param t1 the Tuple3b containing the initialization x y z data
*/
public Tuple3b(Tuple3b t1)
{
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
}
/**
* Constructs and initializes a Tuple3b to (0,0,0).
*/
public Tuple3b()
{
this.x = (byte) 0;
this.y = (byte) 0;
this.z = (byte) 0;
}
/**
* Returns a string that contains the values of this Tuple3b.
* @return a String with the values
*/
public String toString()
{
return("(" + ((int)this.x & 0xff) +
", " + ((int)this.y & 0xff) +
", " + ((int)this.z & 0xff) + ")");
}
/**
* Places the value of the x,y,z components of this Tuple3b
* into the array of length 3.
* @param t array of length 3 into which the component values are copied
*/
public final void get(byte[] t)
{
t[0] = this.x;
t[1] = this.y;
t[2] = this.z;
}
/**
* Places the value of the x,y,z components of this tuple into
* the tuple t1.
* @param t1 the tuple into which the values are placed
*/
public final void get(Tuple3b t1)
{
t1.x = this.x;
t1.y = this.y;
t1.z = this.z;
}
/**
* Sets the value of the data members of this tuple to the value
* of the argument tuple t1.
* @param t1 the source tuple for the memberwise copy
*/
public final void set(Tuple3b t1)
{
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
}
/**
* Sets the value of the x,y,z, data members of this tuple to the
* values in the array t of length 3.
* @param t array of length 3 which is the source for the memberwise copy
*/
public final void set(byte[] t)
{
this.x = t[0];
this.y = t[1];
this.z = t[2];
}
/**
* Returns true if all of the data members of tuple t1 are equal to
* the corresponding data members in this tuple.
* @param t1 the tuple with which the comparison is made
* @return true or false
*/
public boolean equals(Tuple3b t1)
{
try {
return(this.x == t1.x && this.y == t1.y && this.z == t1.z);
}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the Object t1 is of type Tuple3b and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple3b.
* @param t1 the object with which the comparison is made
*/
public boolean equals(Object t1)
{
try {
Tuple3b t2 = (Tuple3b) t1;
return(this.x == t2.x && this.y == t2.y && this.z == t2.z);
}
catch (NullPointerException e2) {return false;}
catch (ClassCastException e1) {return false;}
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple3b objects with identical data values
* (i.e., Tuple3b.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
return ((((int)x & 0xff) << 0) |
(((int)y & 0xff) << 8) |
(((int)z & 0xff) << 16));
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get x, the first value.
*
* @return the first value.
*
* @since vecmath 1.5
*/
public final byte getX() {
return x;
}
/**
* Set x, the first value.
*
* @param x the first value to set.
*
* @since vecmath 1.5
*/
public final void setX(byte x) {
this.x = x;
}
/**
* Get y, the second value.
*
* @return the second value.
*
* @since vecmath 1.5
*/
public final byte getY() {
return y;
}
/**
* Set y, the second value.
*
* @param y the second value to set.
*
* @since vecmath 1.5
*/
public final void setY(byte y) {
this.y = y;
}
/**
* Get z, the third value.
*
* @return the third value.
*
* @since vecmath 1.5
*/
public final byte getZ() {
return z;
}
/**
* Set z, the third value.
*
* @param z the third value to set.
*
* @since vecmath 1.5
*/
public final void setZ(byte z) {
this.z = z;
}
}
source-cvs/vecmath/src/javax/vecmath/Vector2f.java 0000644 0001750 0001750 00000011312 10761613453 021542 0 ustar jonny jonny /*
* $RCSfile: Vector2f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 2-element vector that is represented by single-precision floating
* point x,y coordinates.
*
*/
public class Vector2f extends Tuple2f implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = -2168194326883512320L;
/**
* Constructs and initializes a Vector2f from the specified xy coordinates.
* @param x the x coordinate
* @param y the y coordinate
*/
public Vector2f(float x, float y)
{
super(x,y);
}
/**
* Constructs and initializes a Vector2f from the specified array.
* @param v the array of length 2 containing xy in order
*/
public Vector2f(float[] v)
{
super(v);
}
/**
* Constructs and initializes a Vector2f from the specified Vector2f.
* @param v1 the Vector2f containing the initialization x y data
*/
public Vector2f(Vector2f v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector2f from the specified Vector2d.
* @param v1 the Vector2d containing the initialization x y data
*/
public Vector2f(Vector2d v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector2f from the specified Tuple2f.
* @param t1 the Tuple2f containing the initialization x y data
*/
public Vector2f(Tuple2f t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector2f from the specified Tuple2d.
* @param t1 the Tuple2d containing the initialization x y data
*/
public Vector2f(Tuple2d t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector2f to (0,0).
*/
public Vector2f()
{
super();
}
/**
* Computes the dot product of the this vector and vector v1.
* @param v1 the other vector
*/
public final float dot(Vector2f v1)
{
return (this.x*v1.x + this.y*v1.y);
}
/**
* Returns the length of this vector.
* @return the length of this vector
*/
public final float length()
{
return (float) Math.sqrt(this.x*this.x + this.y*this.y);
}
/**
* Returns the squared length of this vector.
* @return the squared length of this vector
*/
public final float lengthSquared()
{
return (this.x*this.x + this.y*this.y);
}
/**
* Sets the value of this vector to the normalization of vector v1.
* @param v1 the un-normalized vector
*/
public final void normalize(Vector2f v1)
{
float norm;
norm = (float) (1.0/Math.sqrt(v1.x*v1.x + v1.y*v1.y));
this.x = v1.x*norm;
this.y = v1.y*norm;
}
/**
* Normalizes this vector in place.
*/
public final void normalize()
{
float norm;
norm = (float)
(1.0/Math.sqrt(this.x*this.x + this.y*this.y));
this.x *= norm;
this.y *= norm;
}
/**
* Returns the angle in radians between this vector and the vector
* parameter; the return value is constrained to the range [0,PI].
* @param v1 the other vector
* @return the angle in radians in the range [0,PI]
*/
public final float angle(Vector2f v1)
{
double vDot = this.dot(v1) / ( this.length()*v1.length() );
if( vDot < -1.0) vDot = -1.0;
if( vDot > 1.0) vDot = 1.0;
return((float) (Math.acos( vDot )));
}
}
source-cvs/vecmath/src/javax/vecmath/MismatchedSizeException.java 0000644 0001750 0001750 00000003443 10761613452 024645 0 ustar jonny jonny /*
* $RCSfile: MismatchedSizeException.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
/**
* Indicates that an operation cannot be completed properly because
* of a mismatch in the sizes of object attributes.
*/
public class MismatchedSizeException extends RuntimeException{
/**
* Create the exception object with default values.
*/
public MismatchedSizeException(){
}
/**
* Create the exception object that outputs a message.
* @param str the message string to be output.
*/
public MismatchedSizeException(String str){
super(str);
}
}
source-cvs/vecmath/src/javax/vecmath/Vector3d.java 0000644 0001750 0001750 00000012546 10761613453 021553 0 ustar jonny jonny /*
* $RCSfile: Vector3d.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:51 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 3-element vector that is represented by double-precision floating point
* x,y,z coordinates. If this value represents a normal, then it should
* be normalized.
*
*/
public class Vector3d extends Tuple3d implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = 3761969948420550442L;
/**
* Constructs and initializes a Vector3d from the specified xyz coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public Vector3d(double x, double y, double z)
{
super(x,y,z);
}
/**
* Constructs and initializes a Vector3d from the array of length 3.
* @param v the array of length 3 containing xyz in order
*/
public Vector3d(double[] v)
{
super(v);
}
/**
* Constructs and initializes a Vector3d from the specified Vector3d.
* @param v1 the Vector3d containing the initialization x y z data
*/
public Vector3d(Vector3d v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector3d from the specified Vector3f.
* @param v1 the Vector3f containing the initialization x y z data
*/
public Vector3d(Vector3f v1)
{
super(v1);
}
/**
* Constructs and initializes a Vector3d from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public Vector3d(Tuple3f t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector3d from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public Vector3d(Tuple3d t1)
{
super(t1);
}
/**
* Constructs and initializes a Vector3d to (0,0,0).
*/
public Vector3d()
{
super();
}
/**
* Sets this vector to the vector cross product of vectors v1 and v2.
* @param v1 the first vector
* @param v2 the second vector
*/
public final void cross(Vector3d v1, Vector3d v2)
{
double x,y;
x = v1.y*v2.z - v1.z*v2.y;
y = v2.x*v1.z - v2.z*v1.x;
this.z = v1.x*v2.y - v1.y*v2.x;
this.x = x;
this.y = y;
}
/**
* Sets the value of this vector to the normalization of vector v1.
* @param v1 the un-normalized vector
*/
public final void normalize(Vector3d v1)
{
double norm;
norm = 1.0/Math.sqrt(v1.x*v1.x + v1.y*v1.y + v1.z*v1.z);
this.x = v1.x*norm;
this.y = v1.y*norm;
this.z = v1.z*norm;
}
/**
* Normalizes this vector in place.
*/
public final void normalize()
{
double norm;
norm = 1.0/Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.z);
this.x *= norm;
this.y *= norm;
this.z *= norm;
}
/**
* Returns the dot product of this vector and vector v1.
* @param v1 the other vector
* @return the dot product of this and v1
*/
public final double dot(Vector3d v1)
{
return (this.x*v1.x + this.y*v1.y + this.z*v1.z);
}
/**
* Returns the squared length of this vector.
* @return the squared length of this vector
*/
public final double lengthSquared()
{
return (this.x*this.x + this.y*this.y + this.z*this.z);
}
/**
* Returns the length of this vector.
* @return the length of this vector
*/
public final double length()
{
return Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.z);
}
/**
* Returns the angle in radians between this vector and the vector
* parameter; the return value is constrained to the range [0,PI].
* @param v1 the other vector
* @return the angle in radians in the range [0,PI]
*/
public final double angle(Vector3d v1)
{
double vDot = this.dot(v1) / ( this.length()*v1.length() );
if( vDot < -1.0) vDot = -1.0;
if( vDot > 1.0) vDot = 1.0;
return((double) (Math.acos( vDot )));
}
}
source-cvs/vecmath/src/javax/vecmath/AxisAngle4f.java 0000644 0001750 0001750 00000036505 10761613452 022167 0 ustar jonny jonny /*
* $RCSfile: AxisAngle4f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.8 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A four-element axis angle represented by single-precision floating point
* x,y,z,angle components. An axis angle is a rotation of angle (radians)
* about the vector (x,y,z).
*
*/
public class AxisAngle4f implements java.io.Serializable, Cloneable {
// Compatible with 1.1
static final long serialVersionUID = -163246355858070601L;
/**
* The x coordinate.
*/
public float x;
/**
* The y coordinate.
*/
public float y;
/**
* The z coordinate.
*/
public float z;
/**
* The angle of rotation in radians.
*/
public float angle;
final static double EPS = 0.000001;
/**
* Constructs and initializes a AxisAngle4f from the specified xyzw coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param angle the angle of rotation in radians
*/
public AxisAngle4f(float x, float y, float z, float angle)
{
this.x = x;
this.y = y;
this.z = z;
this.angle = angle;
}
/**
* Constructs and initializes an AxisAngle4f from the array of length 4.
* @param a the array of length 4 containing x,y,z,angle in order
*/
public AxisAngle4f(float[] a)
{
this.x = a[0];
this.y = a[1];
this.z = a[2];
this.angle = a[3];
}
/**
* Constructs and initializes an AxisAngle4f from the specified
* AxisAngle4f.
* @param a1 the AxisAngle4f containing the initialization x y z angle data
*/
public AxisAngle4f(AxisAngle4f a1)
{
this.x = a1.x;
this.y = a1.y;
this.z = a1.z;
this.angle = a1.angle;
}
/**
* Constructs and initializes an AxisAngle4f from the specified AxisAngle4d.
* @param a1 the AxisAngle4d containing the initialization x y z angle data
*/
public AxisAngle4f(AxisAngle4d a1)
{
this.x = (float) a1.x;
this.y = (float) a1.y;
this.z = (float) a1.z;
this.angle = (float) a1.angle;
}
/**
* Constructs and initializes an AxisAngle4f from the specified
* axis and angle.
* @param axis the axis
* @param angle the angle of rotation in radians
*
* @since vecmath 1.2
*/
public AxisAngle4f(Vector3f axis, float angle) {
this.x = axis.x;
this.y = axis.y;
this.z = axis.z;
this.angle = angle;
}
/**
* Constructs and initializes an AxisAngle4f to (0,0,1,0).
*/
public AxisAngle4f()
{
this.x = 0.0f;
this.y = 0.0f;
this.z = 1.0f;
this.angle = 0.0f;
}
/**
* Sets the value of this axis-angle to the specified x,y,z,angle.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param angle the angle of rotation in radians
*/
public final void set(float x, float y, float z, float angle)
{
this.x = x;
this.y = y;
this.z = z;
this.angle = angle;
}
/**
* Sets the value of this axis-angle to the specified values in the
* array of length 4.
* @param a the array of length 4 containing x,y,z,angle in order
*/
public final void set(float[] a)
{
this.x = a[0];
this.y = a[1];
this.z = a[2];
this.angle = a[3];
}
/**
* Sets the value of this axis-angle to the value of axis-angle a1.
* @param a1 the axis-angle to be copied
*/
public final void set(AxisAngle4f a1)
{
this.x = a1.x;
this.y = a1.y;
this.z = a1.z;
this.angle = a1.angle;
}
/**
* Sets the value of this axis-angle to the value of axis-angle a1.
* @param a1 the axis-angle to be copied
*/
public final void set(AxisAngle4d a1)
{
this.x = (float) a1.x;
this.y = (float) a1.y;
this.z = (float) a1.z;
this.angle = (float) a1.angle;
}
/**
* Sets the value of this AxisAngle4f to the specified
* axis and angle.
* @param axis the axis
* @param angle the angle of rotation in radians
*
* @since vecmath 1.2
*/
public final void set(Vector3f axis, float angle) {
this.x = axis.x;
this.y = axis.y;
this.z = axis.z;
this.angle = angle;
}
/**
* Copies the value of this axis-angle into the array a.
* @param a the array
*/
public final void get(float[] a)
{
a[0] = this.x;
a[1] = this.y;
a[2] = this.z;
a[3] = this.angle;
}
/**
* Sets the value of this axis-angle to the rotational equivalent
* of the passed quaternion.
* If the specified quaternion has no rotational component, the value
* of this AxisAngle4f is set to an angle of 0 about an axis of (0,1,0).
* @param q1 the Quat4f
*/
public final void set(Quat4f q1)
{
double mag = q1.x*q1.x + q1.y*q1.y + q1.z*q1.z;
if ( mag > EPS ) {
mag = Math.sqrt(mag);
double invMag = 1.0/mag;
x = (float)(q1.x*invMag);
y = (float)(q1.y*invMag);
z = (float)(q1.z*invMag);
angle = (float)(2.0*Math.atan2(mag, q1.w));
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational equivalent
* of the passed quaternion.
* If the specified quaternion has no rotational component, the value
* of this AxisAngle4f is set to an angle of 0 about an axis of (0,1,0).
* @param q1 the Quat4d
*/
public final void set(Quat4d q1)
{
double mag = q1.x*q1.x + q1.y*q1.y + q1.z*q1.z;
if (mag > EPS) {
mag = Math.sqrt(mag);
double invMag = 1.0/mag;
x = (float)(q1.x*invMag);
y = (float)(q1.y*invMag);
z = (float)(q1.z*invMag);
angle = (float)(2.0*Math.atan2(mag, q1.w));
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4f is set to an angle of 0 about an axis of (0,1,0).
* @param m1 the matrix4f
*/
public final void set(Matrix4f m1)
{
Matrix3f m3f = new Matrix3f();
m1.get(m3f);
x = m3f.m21 - m3f.m12;
y = m3f.m02 - m3f.m20;
z = m3f.m10 - m3f.m01;
double mag = x*x + y*y + z*z;
if (mag > EPS) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m3f.m00 + m3f.m11 + m3f.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = (float)(x*invMag);
y = (float)(y*invMag);
z = (float)(z*invMag);
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4f is set to an angle of 0 about an axis of (0,1,0).
* @param m1 the matrix4d
*/
public final void set(Matrix4d m1)
{
Matrix3d m3d = new Matrix3d();
m1.get(m3d);
x = (float)(m3d.m21 - m3d.m12);
y = (float)(m3d.m02 - m3d.m20);
z = (float)(m3d.m10 - m3d.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m3d.m00 + m3d.m11 + m3d.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = (float)(x*invMag);
y = (float)(y*invMag);
z = (float)(z*invMag);
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4f is set to an angle of 0 about an axis of (0,1,0).
* @param m1 the matrix3f
*/
public final void set(Matrix3f m1)
{
x = (float)(m1.m21 - m1.m12);
y = (float)(m1.m02 - m1.m20);
z = (float)(m1.m10 - m1.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m1.m00 + m1.m11 + m1.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = (float)(x*invMag);
y = (float)(y*invMag);
z = (float)(z*invMag);
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Sets the value of this axis-angle to the rotational component of
* the passed matrix.
* If the specified matrix has no rotational component, the value
* of this AxisAngle4f is set to an angle of 0 about an axis of (0,1,0).
* @param m1 the matrix3d
*/
public final void set(Matrix3d m1)
{
x = (float)(m1.m21 - m1.m12);
y = (float)(m1.m02 - m1.m20);
z = (float)(m1.m10 - m1.m01);
double mag = x*x + y*y + z*z;
if (mag > EPS) {
mag = Math.sqrt(mag);
double sin = 0.5*mag;
double cos = 0.5*(m1.m00 + m1.m11 + m1.m22 - 1.0);
angle = (float)Math.atan2(sin, cos);
double invMag = 1.0/mag;
x = (float)(x*invMag);
y = (float)(y*invMag);
z = (float)(z*invMag);
} else {
x = 0.0f;
y = 1.0f;
z = 0.0f;
angle = 0.0f;
}
}
/**
* Returns a string that contains the values of this AxisAngle4f.
* The form is (x,y,z,angle).
* @return the String representation
*/
public String toString() {
return "(" + this.x + ", " + this.y + ", " + this.z + ", " + this.angle + ")";
}
/**
* Returns true if all of the data members of AxisAngle4f a1 are
* equal to the corresponding data members in this AxisAngle4f.
* @param a1 the axis-angle with which the comparison is made
* @return true or false
*/
public boolean equals(AxisAngle4f a1)
{
try {
return(this.x == a1.x && this.y == a1.y && this.z == a1.z
&& this.angle == a1.angle);
}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the Object o1 is of type AxisAngle4f and all of the
* data members of o1 are equal to the corresponding data members in
* this AxisAngle4f.
* @param o1 the object with which the comparison is made
* @return true or false
*/
public boolean equals(Object o1)
{
try {
AxisAngle4f a2 = (AxisAngle4f) o1;
return(this.x == a2.x && this.y == a2.y && this.z == a2.z
&& this.angle == a2.angle);
}
catch (NullPointerException e2) {return false;}
catch (ClassCastException e1) {return false;}
}
/**
* Returns true if the L-infinite distance between this axis-angle
* and axis-angle a1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to
* MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2), abs(angle1-angle2)].
* @param a1 the axis-angle to be compared to this axis-angle
* @param epsilon the threshold value
*/
public boolean epsilonEquals(AxisAngle4f a1, float epsilon)
{
float diff;
diff = x - a1.x;
if((diff<0?-diff:diff) > epsilon) return false;
diff = y - a1.y;
if((diff<0?-diff:diff) > epsilon) return false;
diff = z - a1.z;
if((diff<0?-diff:diff) > epsilon) return false;
diff = angle - a1.angle;
if((diff<0?-diff:diff) > epsilon) return false;
return true;
}
/**
* Returns a hash code value based on the data values in this
* object. Two different AxisAngle4f objects with identical data values
* (i.e., AxisAngle4f.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + (long)VecMathUtil.floatToIntBits(x);
bits = 31L * bits + (long)VecMathUtil.floatToIntBits(y);
bits = 31L * bits + (long)VecMathUtil.floatToIntBits(z);
bits = 31L * bits + (long)VecMathUtil.floatToIntBits(angle);
return (int) (bits ^ (bits >> 32));
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get the axis angle, in radians.
* An axis angle is a rotation angle about the vector (x,y,z).
*
* @return Returns the angle, in radians.
*
* @since vecmath 1.5
*/
public final float getAngle() {
return angle;
}
/**
* Set the axis angle, in radians.
* An axis angle is a rotation angle about the vector (x,y,z).
*
* @param angle The angle to set, in radians.
*
* @since vecmath 1.5
*/
public final void setAngle(float angle) {
this.angle = angle;
}
/**
* Get value of x coordinate.
*
* @return the x coordinate.
*
* @since vecmath 1.5
*/
public final float getX() {
return x;
}
/**
* Set a new value for x coordinate.
*
* @param x the x coordinate.
*
* @since vecmath 1.5
*/
public final void setX(float x) {
this.x = x;
}
/**
* Get value of y coordinate.
*
* @return the y coordinate
*
* @since vecmath 1.5
*/
public final float getY() {
return y;
}
/**
* Set a new value for y coordinate.
*
* @param y the y coordinate.
*
* @since vecmath 1.5
*/
public final void setY(float y) {
this.y = y;
}
/**
* Get value of z coordinate.
*
* @return the z coordinate.
*
* @since vecmath 1.5
*/
public final float getZ() {
return z;
}
/**
* Set a new value for z coordinate.
*
* @param z the z coordinate.
*
* @since vecmath 1.5
*/
public final void setZ(float z) {
this.z = z;
}
}
source-cvs/vecmath/src/javax/vecmath/ExceptionStrings.properties 0000644 0001750 0001750 00000011320 10061475550 024627 0 ustar jonny jonny Matrix3d0=Matrix3d setElement
Matrix3d1=Matrix3d getElement
Matrix3d2=Matrix3d getRow
Matrix3d4=Matrix3d getColumn
Matrix3d6=Matrix3d setRow
Matrix3d9=Matrix3d setColumn
Matrix3d12=cannot invert matrix
Matrix3d13=Logic error: imax < 0
Matrix3f0=Matrix3f setElement
Matrix3f1=Matrix3d getRow
Matrix3f3=Matrix3d getColumn
Matrix3f5=Matrix3f getElement
Matrix3f6=Matrix3f setRow
Matrix3f9=Matrix3f setColumn
Matrix3f12=cannot invert matrix
Matrix3f13=Logic error: imax < 0
Matrix4d0=Matrix4d setElement
Matrix4d1=Matrix4d getElement
Matrix4d2=Matrix4d getRow
Matrix4d3=Matrix4d getColumn
Matrix4d4=Matrix4d setRow
Matrix4d7=Matrix4d setColumn
Matrix4d10=cannot invert matrix
Matrix4d11=Logic error: imax < 0
Matrix4f0=Matrix4f setElement
Matrix4f1=Matrix4f getElement
Matrix4f2=Matrix4f getRow
Matrix4f4=Matrix4f getColumn
Matrix4f6=Matrix4f setRow
Matrix4f9=Matrix4f setColumn
Matrix4f12=cannot invert matrix
Matrix4f13=Logic error: imax < 0
GMatrix0=GMatrix.mul:array dimension mismatch
GMatrix1=GMatrix.mul(GMatrix, GMatrix) dimension mismatch
GMatrix2=GMatrix.mul(GVector, GVector): matrix does not have enough rows
GMatrix3=GMatrix.mul(GVector, GVector): matrix does not have enough columns
GMatrix4=GMatrix.add(GMatrix): row dimension mismatch
GMatrix5=GMatrix.add(GMatrix): column dimension mismatch
GMatrix6=GMatrix.add(GMatrix, GMatrix): row dimension mismatch
GMatrix7=GMatrix.add(GMatrix, GMatrix): column dimension mismatch
GMatrix8=GMatrix.add(GMatrix): input matrices dimensions do not match this matrix dimensions
GMatrix9=GMatrix.sub(GMatrix): row dimension mismatch
GMatrix10=GMatrix.sub(GMatrix, GMatrix): row dimension mismatch
GMatrix11=GMatrix.sub(GMatrix, GMatrix): column dimension mismatch
GMatrix12=GMatrix.sub(GMatrix, GMatrix): input matrix dimensions do not match dimensions for this matrix
GMatrix13=GMatrix.negate(GMatrix, GMatrix): input matrix dimensions do not match dimensions for this matrix
GMatrix14=GMatrix.mulTransposeBoth matrix dimension mismatch
GMatrix15=GMatrix.mulTransposeRight matrix dimension mismatch
GMatrix16=GMatrix.mulTransposeLeft matrix dimension mismatch
GMatrix17=GMatrix.transpose(GMatrix) mismatch in matrix dimensions
GMatrix18=GMatrix.SVD: dimension mismatch with V matrix
GMatrix19=cannot perform LU decomposition on a non square matrix
GMatrix20=row permutation must be same dimension as matrix
GMatrix21=cannot invert matrix
GMatrix22=cannot invert non square matrix
GMatrix24=Logic error: imax < 0
GMatrix25=GMatrix.SVD: dimension mismatch with U matrix
GMatrix26=GMatrix.SVD: dimension mismatch with W matrix
GMatrix27=LU must have same dimensions as this matrix
GMatrix28=GMatrix.sub(GMatrix): column dimension mismatch
GVector0=GVector.normalize( GVector) input vector and this vector lengths not matched
GVector1=GVector.scale(double, GVector) input vector and this vector lengths not matched
GVector2=GVector.scaleAdd(GVector, GVector) input vector dimensions not matched
GVector3=GVector.scaleAdd(GVector, GVector) input vectors and this vector dimensions not matched
GVector4=GVector.add(GVector) input vectors and this vector dimensions not matched
GVector5=GVector.add(GVector, GVector) input vector dimensions not matched
GVector6=GVector.add(GVector, GVector) input vectors and this vector dimensions not matched
GVector7=GVector.sub(GVector) input vector and this vector dimensions not matched
GVector8=GVector.sub(GVector, GVector) input vector dimensions not matched
GVector9=GVector.sub(GMatrix, GVector) input vectors and this vector dimensions not matched
GVector10=GVector.mul(GMatrix, GVector) matrix and vector dimensions not matched
GVector11=GVector.mul(GMatrix, GVector) matrix this vector dimensions not matched
GVector12=GVector.mul(GVector, GMatrix) matrix and vector dimensions not matched
GVector13=GVector.mul(GVector, GMatrix) matrix this vector dimensions not matched
GVector14=GVector.dot(GVector) input vector and this vector have different sizes
GVector15=matrix dimensions are not compatible
GVector16=b vector does not match matrix dimension
GVector17=GVector.interpolate(GVector, GVector, float) input vectors have different lengths
GVector18=GVector.interpolate(GVector, GVector, float) input vectors and this vector have different lengths
GVector19=GVector.interpolate(GVector, float) input vector and this vector have different lengths
GVector20=GVector.interpolate(GVector, GVector, double) input vectors have different lengths
GVector21=GVector.interpolate(GVector, GVector, double) input vectors and this vector have different lengths
GVector22=GVector.interpolate(GVector, double) input vectors and this vector have different lengths
GVector23=matrix dimensions are not compatible
GVector24=permutation vector does not match matrix dimension
GVector25=LUDBackSolve non square matrix
source-cvs/vecmath/src/javax/vecmath/TexCoord4f.java 0000644 0001750 0001750 00000005767 10761613452 022051 0 ustar jonny jonny /*
* $RCSfile: TexCoord4f.java,v $
*
* Copyright 2001-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.6 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 4 element texture coordinate that is represented by single precision
* floating point x,y,z,w coordinates.
*
* @since vecmath 1.3
*/
public class TexCoord4f extends Tuple4f implements java.io.Serializable {
// Combatible with 1.1
static final long serialVersionUID = -3517736544731446513L;
/**
* Constructs and initializes a TexCoord4f from the specified xyzw
* coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
* @param w the w coordinate
*/
public TexCoord4f(float x, float y, float z, float w)
{
super(x,y,z,w);
}
/**
* Constructs and initializes a TexCoord4f from the array of length 4.
* @param v the array of length w containing xyzw in order
*/
public TexCoord4f(float[] v)
{
super(v);
}
/**
* Constructs and initializes a TexCoord4f from the specified TexCoord4f.
* @param v1 the TexCoord4f containing the initialization x y z w data
*/
public TexCoord4f(TexCoord4f v1)
{
super(v1);
}
/**
* Constructs and initializes a TexCoord4f from the specified Tuple4f.
* @param t1 the Tuple4f containing the initialization x y z w data
*/
public TexCoord4f(Tuple4f t1)
{
super(t1);
}
/**
* Constructs and initializes a TexCoord4f from the specified Tuple4d.
* @param t1 the Tuple4d containing the initialization x y z w data
*/
public TexCoord4f(Tuple4d t1)
{
super(t1);
}
/**
* Constructs and initializes a TexCoord4f to (0,0,0,0).
*/
public TexCoord4f()
{
super();
}
}
source-cvs/vecmath/src/javax/vecmath/Matrix3d.java 0000644 0001750 0001750 00000241742 10761613452 021556 0 ustar jonny jonny /*
* $RCSfile: Matrix3d.java,v $
*
* Copyright 1996-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.8 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A double precision floating point 3 by 3 matrix.
* Primarily to support 3D rotations.
*
*/
public class Matrix3d implements java.io.Serializable, Cloneable {
// Compatible with 1.1
static final long serialVersionUID = 6837536777072402710L;
/**
* The first matrix element in the first row.
*/
public double m00;
/**
* The second matrix element in the first row.
*/
public double m01;
/**
* The third matrix element in the first row.
*/
public double m02;
/**
* The first matrix element in the second row.
*/
public double m10;
/**
* The second matrix element in the second row.
*/
public double m11;
/**
* The third matrix element in the second row.
*/
public double m12;
/**
* The first matrix element in the third row.
*/
public double m20;
/**
* The second matrix element in the third row.
*/
public double m21;
/**
* The third matrix element in the third row.
*/
public double m22;
//double[] tmp = new double[9]; // scratch matrix
//double[] tmp_rot = new double[9]; // scratch matrix
//double[] tmp_scale = new double[3]; // scratch matrix
private static final double EPS = 1.110223024E-16;
private static final double ERR_EPS = 1.0E-8;
private static double xin,yin,zin,xout,yout,zout;
/**
* Constructs and initializes a Matrix3d from the specified nine values.
* @param m00 the [0][0] element
* @param m01 the [0][1] element
* @param m02 the [0][2] element
* @param m10 the [1][0] element
* @param m11 the [1][1] element
* @param m12 the [1][2] element
* @param m20 the [2][0] element
* @param m21 the [2][1] element
* @param m22 the [2][2] element
*/
public Matrix3d(double m00, double m01, double m02,
double m10, double m11, double m12,
double m20, double m21, double m22)
{
this.m00 = m00;
this.m01 = m01;
this.m02 = m02;
this.m10 = m10;
this.m11 = m11;
this.m12 = m12;
this.m20 = m20;
this.m21 = m21;
this.m22 = m22;
}
/**
* Constructs and initializes a Matrix3d from the specified nine-
* element array.
* @param v the array of length 9 containing in order
*/
public Matrix3d(double[] v)
{
this.m00 = v[0];
this.m01 = v[1];
this.m02 = v[2];
this.m10 = v[3];
this.m11 = v[4];
this.m12 = v[5];
this.m20 = v[6];
this.m21 = v[7];
this.m22 = v[8];
}
/**
* Constructs a new matrix with the same values as the
* Matrix3d parameter.
* @param m1 the source matrix
*/
public Matrix3d(Matrix3d m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
}
/**
* Constructs a new matrix with the same values as the
* Matrix3f parameter.
* @param m1 the source matrix
*/
public Matrix3d(Matrix3f m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
}
/**
* Constructs and initializes a Matrix3d to all zeros.
*/
public Matrix3d()
{
this.m00 = 0.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m10 = 0.0;
this.m11 = 0.0;
this.m12 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 0.0;
}
/**
* Returns a string that contains the values of this Matrix3d.
* @return the String representation
*/
public String toString() {
return
this.m00 + ", " + this.m01 + ", " + this.m02 + "\n" +
this.m10 + ", " + this.m11 + ", " + this.m12 + "\n" +
this.m20 + ", " + this.m21 + ", " + this.m22 + "\n";
}
/**
* Sets this Matrix3d to identity.
*/
public final void setIdentity()
{
this.m00 = 1.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m10 = 0.0;
this.m11 = 1.0;
this.m12 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 1.0;
}
/**
* Sets the scale component of the current matrix by factoring
* out the current scale (by doing an SVD) and multiplying by
* the new scale.
* @param scale the new scale amount
*/
public final void setScale(double scale)
{
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate(tmp_scale, tmp_rot);
this.m00 = tmp_rot[0] * scale;
this.m01 = tmp_rot[1] * scale;
this.m02 = tmp_rot[2] * scale;
this.m10 = tmp_rot[3] * scale;
this.m11 = tmp_rot[4] * scale;
this.m12 = tmp_rot[5] * scale;
this.m20 = tmp_rot[6] * scale;
this.m21 = tmp_rot[7] * scale;
this.m22 = tmp_rot[8] * scale;
}
/**
* Sets the specified element of this matrix3f to the value provided.
* @param row the row number to be modified (zero indexed)
* @param column the column number to be modified (zero indexed)
* @param value the new value
*/
public final void setElement(int row, int column, double value)
{
switch (row)
{
case 0:
switch(column)
{
case 0:
this.m00 = value;
break;
case 1:
this.m01 = value;
break;
case 2:
this.m02 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d0"));
}
break;
case 1:
switch(column)
{
case 0:
this.m10 = value;
break;
case 1:
this.m11 = value;
break;
case 2:
this.m12 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d0"));
}
break;
case 2:
switch(column)
{
case 0:
this.m20 = value;
break;
case 1:
this.m21 = value;
break;
case 2:
this.m22 = value;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d0"));
}
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d0"));
}
}
/**
* Retrieves the value at the specified row and column of the specified
* matrix.
* @param row the row number to be retrieved (zero indexed)
* @param column the column number to be retrieved (zero indexed)
* @return the value at the indexed element.
*/
public final double getElement(int row, int column)
{
switch (row)
{
case 0:
switch(column)
{
case 0:
return(this.m00);
case 1:
return(this.m01);
case 2:
return(this.m02);
default:
break;
}
break;
case 1:
switch(column)
{
case 0:
return(this.m10);
case 1:
return(this.m11);
case 2:
return(this.m12);
default:
break;
}
break;
case 2:
switch(column)
{
case 0:
return(this.m20);
case 1:
return(this.m21);
case 2:
return(this.m22);
default:
break;
}
break;
default:
break;
}
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d1"));
}
/**
* Copies the matrix values in the specified row into the vector parameter.
* @param row the matrix row
* @param v the vector into which the matrix row values will be copied
*/
public final void getRow(int row, Vector3d v) {
if( row == 0 ) {
v.x = m00;
v.y = m01;
v.z = m02;
} else if(row == 1) {
v.x = m10;
v.y = m11;
v.z = m12;
} else if(row == 2) {
v.x = m20;
v.y = m21;
v.z = m22;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d2"));
}
}
/**
* Copies the matrix values in the specified row into the array parameter.
* @param row the matrix row
* @param v the array into which the matrix row values will be copied
*/
public final void getRow(int row, double v[]) {
if( row == 0 ) {
v[0] = m00;
v[1] = m01;
v[2] = m02;
} else if(row == 1) {
v[0] = m10;
v[1] = m11;
v[2] = m12;
} else if(row == 2) {
v[0] = m20;
v[1] = m21;
v[2] = m22;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d2"));
}
}
/**
* Copies the matrix values in the specified column into the vector
* parameter.
* @param column the matrix column
* @param v the vector into which the matrix row values will be copied
*/
public final void getColumn(int column, Vector3d v) {
if( column == 0 ) {
v.x = m00;
v.y = m10;
v.z = m20;
} else if(column == 1) {
v.x = m01;
v.y = m11;
v.z = m21;
}else if(column == 2){
v.x = m02;
v.y = m12;
v.z = m22;
} else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d4"));
}
}
/**
* Copies the matrix values in the specified column into the array
* parameter.
* @param column the matrix column
* @param v the array into which the matrix row values will be copied
*/
public final void getColumn(int column, double v[]) {
if( column == 0 ) {
v[0] = m00;
v[1] = m10;
v[2] = m20;
} else if(column == 1) {
v[0] = m01;
v[1] = m11;
v[2] = m21;
}else if(column == 2) {
v[0] = m02;
v[1] = m12;
v[2] = m22;
}else {
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d4"));
}
}
/**
* Sets the specified row of this matrix3d to the 4 values provided.
* @param row the row number to be modified (zero indexed)
* @param x the first column element
* @param y the second column element
* @param z the third column element
*/
public final void setRow(int row, double x, double y, double z)
{
switch (row) {
case 0:
this.m00 = x;
this.m01 = y;
this.m02 = z;
break;
case 1:
this.m10 = x;
this.m11 = y;
this.m12 = z;
break;
case 2:
this.m20 = x;
this.m21 = y;
this.m22 = z;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d6"));
}
}
/**
* Sets the specified row of this matrix3d to the Vector provided.
* @param row the row number to be modified (zero indexed)
* @param v the replacement row
*/
public final void setRow(int row, Vector3d v)
{
switch (row) {
case 0:
this.m00 = v.x;
this.m01 = v.y;
this.m02 = v.z;
break;
case 1:
this.m10 = v.x;
this.m11 = v.y;
this.m12 = v.z;
break;
case 2:
this.m20 = v.x;
this.m21 = v.y;
this.m22 = v.z;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d6"));
}
}
/**
* Sets the specified row of this matrix3d to the three values provided.
* @param row the row number to be modified (zero indexed)
* @param v the replacement row
*/
public final void setRow(int row, double v[])
{
switch (row) {
case 0:
this.m00 = v[0];
this.m01 = v[1];
this.m02 = v[2];
break;
case 1:
this.m10 = v[0];
this.m11 = v[1];
this.m12 = v[2];
break;
case 2:
this.m20 = v[0];
this.m21 = v[1];
this.m22 = v[2];
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d6"));
}
}
/**
* Sets the specified column of this matrix3d to the three values provided.
* @param column the column number to be modified (zero indexed)
* @param x the first row element
* @param y the second row element
* @param z the third row element
*/
public final void setColumn(int column, double x, double y, double z)
{
switch (column) {
case 0:
this.m00 = x;
this.m10 = y;
this.m20 = z;
break;
case 1:
this.m01 = x;
this.m11 = y;
this.m21 = z;
break;
case 2:
this.m02 = x;
this.m12 = y;
this.m22 = z;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d9"));
}
}
/**
* Sets the specified column of this matrix3d to the vector provided.
* @param column the column number to be modified (zero indexed)
* @param v the replacement column
*/
public final void setColumn(int column, Vector3d v)
{
switch (column) {
case 0:
this.m00 = v.x;
this.m10 = v.y;
this.m20 = v.z;
break;
case 1:
this.m01 = v.x;
this.m11 = v.y;
this.m21 = v.z;
break;
case 2:
this.m02 = v.x;
this.m12 = v.y;
this.m22 = v.z;
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d9"));
}
}
/**
* Sets the specified column of this matrix3d to the three values provided.
* @param column the column number to be modified (zero indexed)
* @param v the replacement column
*/
public final void setColumn(int column, double v[])
{
switch (column) {
case 0:
this.m00 = v[0];
this.m10 = v[1];
this.m20 = v[2];
break;
case 1:
this.m01 = v[0];
this.m11 = v[1];
this.m21 = v[2];
break;
case 2:
this.m02 = v[0];
this.m12 = v[1];
this.m22 = v[2];
break;
default:
throw new ArrayIndexOutOfBoundsException(VecMathI18N.getString("Matrix3d9"));
}
}
/**
* Performs an SVD normalization of this 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 will
* be returned. This matrix is not modified.
* @return the scale factor of this matrix
*/
public final double getScale()
{
double[] tmp_scale = new double[3]; // scratch matrix
double[] tmp_rot = new double[9]; // scratch matrix
getScaleRotate(tmp_scale, tmp_rot);
return( max3(tmp_scale) );
}
/**
* Adds a scalar to each component of this matrix.
* @param scalar the scalar adder
*/
public final void add(double scalar)
{
m00 += scalar;
m01 += scalar;
m02 += scalar;
m10 += scalar;
m11 += scalar;
m12 += scalar;
m20 += scalar;
m21 += scalar;
m22 += scalar;
}
/**
* Adds a scalar to each component of the matrix m1 and places
* the result into this. Matrix m1 is not modified.
* @param scalar the scalar adder
* @param m1 the original matrix values
*/
public final void add(double scalar, Matrix3d m1)
{
this.m00 = m1.m00 + scalar;
this.m01 = m1.m01 + scalar;
this.m02 = m1.m02 + scalar;
this.m10 = m1.m10 + scalar;
this.m11 = m1.m11 + scalar;
this.m12 = m1.m12 + scalar;
this.m20 = m1.m20 + scalar;
this.m21 = m1.m21 + scalar;
this.m22 = m1.m22 + scalar;
}
/**
* Sets the value of this matrix to the matrix sum of matrices m1 and m2.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void add(Matrix3d m1, Matrix3d m2)
{
this.m00 = m1.m00 + m2.m00;
this.m01 = m1.m01 + m2.m01;
this.m02 = m1.m02 + m2.m02;
this.m10 = m1.m10 + m2.m10;
this.m11 = m1.m11 + m2.m11;
this.m12 = m1.m12 + m2.m12;
this.m20 = m1.m20 + m2.m20;
this.m21 = m1.m21 + m2.m21;
this.m22 = m1.m22 + m2.m22;
}
/**
* Sets the value of this matrix to the sum of itself and matrix m1.
* @param m1 the other matrix
*/
public final void add(Matrix3d m1)
{
this.m00 += m1.m00;
this.m01 += m1.m01;
this.m02 += m1.m02;
this.m10 += m1.m10;
this.m11 += m1.m11;
this.m12 += m1.m12;
this.m20 += m1.m20;
this.m21 += m1.m21;
this.m22 += m1.m22;
}
/**
* Sets the value of this matrix to the matrix difference
* of matrices m1 and m2.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void sub(Matrix3d m1, Matrix3d m2)
{
this.m00 = m1.m00 - m2.m00;
this.m01 = m1.m01 - m2.m01;
this.m02 = m1.m02 - m2.m02;
this.m10 = m1.m10 - m2.m10;
this.m11 = m1.m11 - m2.m11;
this.m12 = m1.m12 - m2.m12;
this.m20 = m1.m20 - m2.m20;
this.m21 = m1.m21 - m2.m21;
this.m22 = m1.m22 - m2.m22;
}
/**
* Sets the value of this matrix to the matrix difference of itself and
* matrix m1 (this = this - m1).
* @param m1 the other matrix
*/
public final void sub(Matrix3d m1)
{
this.m00 -= m1.m00;
this.m01 -= m1.m01;
this.m02 -= m1.m02;
this.m10 -= m1.m10;
this.m11 -= m1.m11;
this.m12 -= m1.m12;
this.m20 -= m1.m20;
this.m21 -= m1.m21;
this.m22 -= m1.m22;
}
/**
* Sets the value of this matrix to its transpose.
*/
public final void transpose()
{
double temp;
temp = this.m10;
this.m10 = this.m01;
this.m01 = temp;
temp = this.m20;
this.m20 = this.m02;
this.m02 = temp;
temp = this.m21;
this.m21 = this.m12;
this.m12 = temp;
}
/**
* Sets the value of this matrix to the transpose of the argument matrix.
* @param m1 the matrix to be transposed
*/
public final void transpose(Matrix3d m1)
{
if (this != m1) {
this.m00 = m1.m00;
this.m01 = m1.m10;
this.m02 = m1.m20;
this.m10 = m1.m01;
this.m11 = m1.m11;
this.m12 = m1.m21;
this.m20 = m1.m02;
this.m21 = m1.m12;
this.m22 = m1.m22;
} else
this.transpose();
}
/**
* Sets the value of this matrix to the matrix conversion of the
* double precision quaternion argument.
* @param q1 the quaternion to be converted
*/
public final void set(Quat4d q1)
{
this.m00 = (1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = (2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = (2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = (2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = (2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = (2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = (2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
}
/**
* Sets the value of this matrix to the matrix conversion of the
* double precision axis and angle argument.
* @param a1 the axis and angle to be converted
*/
public final void set(AxisAngle4d a1)
{
double mag = Math.sqrt( a1.x*a1.x + a1.y*a1.y + a1.z*a1.z);
if( mag < EPS ) {
m00 = 1.0;
m01 = 0.0;
m02 = 0.0;
m10 = 0.0;
m11 = 1.0;
m12 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 1.0;
} else {
mag = 1.0/mag;
double ax = a1.x*mag;
double ay = a1.y*mag;
double az = a1.z*mag;
double sinTheta = Math.sin(a1.angle);
double cosTheta = Math.cos(a1.angle);
double t = 1.0 - cosTheta;
double xz = ax * az;
double xy = ax * ay;
double yz = ay * az;
m00 = t * ax * ax + cosTheta;
m01 = t * xy - sinTheta * az;
m02 = t * xz + sinTheta * ay;
m10 = t * xy + sinTheta * az;
m11 = t * ay * ay + cosTheta;
m12 = t * yz - sinTheta * ax;
m20 = t * xz - sinTheta * ay;
m21 = t * yz + sinTheta * ax;
m22 = t * az * az + cosTheta;
}
}
/**
* Sets the value of this matrix to the matrix conversion of the
* single precision quaternion argument.
* @param q1 the quaternion to be converted
*/
public final void set(Quat4f q1)
{
this.m00 = (1.0 - 2.0*q1.y*q1.y - 2.0*q1.z*q1.z);
this.m10 = (2.0*(q1.x*q1.y + q1.w*q1.z));
this.m20 = (2.0*(q1.x*q1.z - q1.w*q1.y));
this.m01 = (2.0*(q1.x*q1.y - q1.w*q1.z));
this.m11 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.z*q1.z);
this.m21 = (2.0*(q1.y*q1.z + q1.w*q1.x));
this.m02 = (2.0*(q1.x*q1.z + q1.w*q1.y));
this.m12 = (2.0*(q1.y*q1.z - q1.w*q1.x));
this.m22 = (1.0 - 2.0*q1.x*q1.x - 2.0*q1.y*q1.y);
}
/**
* Sets the value of this matrix to the matrix conversion of the
* single precision axis and angle argument.
* @param a1 the axis and angle to be converted
*/
public final void set(AxisAngle4f a1)
{
double mag = Math.sqrt( a1.x*a1.x + a1.y*a1.y + a1.z*a1.z);
if( mag < EPS ) {
m00 = 1.0;
m01 = 0.0;
m02 = 0.0;
m10 = 0.0;
m11 = 1.0;
m12 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 1.0;
} else {
mag = 1.0/mag;
double ax = a1.x*mag;
double ay = a1.y*mag;
double az = a1.z*mag;
double sinTheta = Math.sin(a1.angle);
double cosTheta = Math.cos(a1.angle);
double t = 1.0 - cosTheta;
double xz = ax * az;
double xy = ax * ay;
double yz = ay * az;
m00 = t * ax * ax + cosTheta;
m01 = t * xy - sinTheta * az;
m02 = t * xz + sinTheta * ay;
m10 = t * xy + sinTheta * az;
m11 = t * ay * ay + cosTheta;
m12 = t * yz - sinTheta * ax;
m20 = t * xz - sinTheta * ay;
m21 = t * yz + sinTheta * ax;
m22 = t * az * az + cosTheta;
}
}
/**
* Sets the value of this matrix to the double value of the Matrix3f
* argument.
* @param m1 the matrix3d to be converted to double
*/
public final void set(Matrix3f m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
}
/**
* Sets the value of this matrix to the value of the Matrix3d
* argument.
* @param m1 the source matrix3d
*/
public final void set(Matrix3d m1)
{
this.m00 = m1.m00;
this.m01 = m1.m01;
this.m02 = m1.m02;
this.m10 = m1.m10;
this.m11 = m1.m11;
this.m12 = m1.m12;
this.m20 = m1.m20;
this.m21 = m1.m21;
this.m22 = m1.m22;
}
/**
* Sets the values in this Matrix3d equal to the row-major
* array parameter (ie, the first three elements of the
* array will be copied into the first row of this matrix, etc.).
* @param m the double precision array of length 9
*/
public final void set(double[] m)
{
m00 = m[0];
m01 = m[1];
m02 = m[2];
m10 = m[3];
m11 = m[4];
m12 = m[5];
m20 = m[6];
m21 = m[7];
m22 = m[8];
}
/**
* Sets the value of this matrix to the matrix inverse
* of the passed matrix m1.
* @param m1 the matrix to be inverted
*/
public final void invert(Matrix3d m1)
{
invertGeneral( m1 );
}
/**
* Inverts this matrix in place.
*/
public final void invert()
{
invertGeneral( this );
}
/**
* General invert routine. Inverts m1 and places the result in "this".
* Note that this routine handles both the "this" version and the
* non-"this" version.
*
* Also note that since this routine is slow anyway, we won't worry
* about allocating a little bit of garbage.
*/
private final void invertGeneral(Matrix3d m1) {
double result[] = new double[9];
int row_perm[] = new int[3];
int i, r, c;
double[] tmp = new double[9]; // scratch matrix
// Use LU decomposition and backsubstitution code specifically
// for floating-point 3x3 matrices.
// Copy source matrix to t1tmp
tmp[0] = m1.m00;
tmp[1] = m1.m01;
tmp[2] = m1.m02;
tmp[3] = m1.m10;
tmp[4] = m1.m11;
tmp[5] = m1.m12;
tmp[6] = m1.m20;
tmp[7] = m1.m21;
tmp[8] = m1.m22;
// Calculate LU decomposition: Is the matrix singular?
if (!luDecomposition(tmp, row_perm)) {
// Matrix has no inverse
throw new SingularMatrixException(VecMathI18N.getString("Matrix3d12"));
}
// Perform back substitution on the identity matrix
for(i=0;i<9;i++) result[i] = 0.0;
result[0] = 1.0; result[4] = 1.0; result[8] = 1.0;
luBacksubstitution(tmp, row_perm, result);
this.m00 = result[0];
this.m01 = result[1];
this.m02 = result[2];
this.m10 = result[3];
this.m11 = result[4];
this.m12 = result[5];
this.m20 = result[6];
this.m21 = result[7];
this.m22 = result[8];
}
/**
* Given a 3x3 array "matrix0", this function replaces it with the
* LU decomposition of a row-wise permutation of itself. The input
* parameters are "matrix0" and "dimen". The array "matrix0" is also
* an output parameter. The vector "row_perm[3]" is an output
* parameter that contains the row permutations resulting from partial
* pivoting. The output parameter "even_row_xchg" is 1 when the
* number of row exchanges is even, or -1 otherwise. Assumes data
* type is always double.
*
* This function is similar to luDecomposition, except that it
* is tuned specifically for 3x3 matrices.
*
* @return true if the matrix is nonsingular, or false otherwise.
*/
//
// Reference: Press, Flannery, Teukolsky, Vetterling,
// _Numerical_Recipes_in_C_, Cambridge University Press,
// 1988, pp 40-45.
//
static boolean luDecomposition(double[] matrix0,
int[] row_perm) {
double row_scale[] = new double[3];
// Determine implicit scaling information by looping over rows
{
int i, j;
int ptr, rs;
double big, temp;
ptr = 0;
rs = 0;
// For each row ...
i = 3;
while (i-- != 0) {
big = 0.0;
// For each column, find the largest element in the row
j = 3;
while (j-- != 0) {
temp = matrix0[ptr++];
temp = Math.abs(temp);
if (temp > big) {
big = temp;
}
}
// Is the matrix singular?
if (big == 0.0) {
return false;
}
row_scale[rs++] = 1.0 / big;
}
}
{
int j;
int mtx;
mtx = 0;
// For all columns, execute Crout's method
for (j = 0; j < 3; j++) {
int i, imax, k;
int target, p1, p2;
double sum, big, temp;
// Determine elements of upper diagonal matrix U
for (i = 0; i < j; i++) {
target = mtx + (3*i) + j;
sum = matrix0[target];
k = i;
p1 = mtx + (3*i);
p2 = mtx + j;
while (k-- != 0) {
sum -= matrix0[p1] * matrix0[p2];
p1++;
p2 += 3;
}
matrix0[target] = sum;
}
// Search for largest pivot element and calculate
// intermediate elements of lower diagonal matrix L.
big = 0.0;
imax = -1;
for (i = j; i < 3; i++) {
target = mtx + (3*i) + j;
sum = matrix0[target];
k = j;
p1 = mtx + (3*i);
p2 = mtx + j;
while (k-- != 0) {
sum -= matrix0[p1] * matrix0[p2];
p1++;
p2 += 3;
}
matrix0[target] = sum;
// Is this the best pivot so far?
if ((temp = row_scale[i] * Math.abs(sum)) >= big) {
big = temp;
imax = i;
}
}
if (imax < 0) {
throw new RuntimeException(VecMathI18N.getString("Matrix3d13"));
}
// Is a row exchange necessary?
if (j != imax) {
// Yes: exchange rows
k = 3;
p1 = mtx + (3*imax);
p2 = mtx + (3*j);
while (k-- != 0) {
temp = matrix0[p1];
matrix0[p1++] = matrix0[p2];
matrix0[p2++] = temp;
}
// Record change in scale factor
row_scale[imax] = row_scale[j];
}
// Record row permutation
row_perm[j] = imax;
// Is the matrix singular
if (matrix0[(mtx + (3*j) + j)] == 0.0) {
return false;
}
// Divide elements of lower diagonal matrix L by pivot
if (j != (3-1)) {
temp = 1.0 / (matrix0[(mtx + (3*j) + j)]);
target = mtx + (3*(j+1)) + j;
i = 2 - j;
while (i-- != 0) {
matrix0[target] *= temp;
target += 3;
}
}
}
}
return true;
}
/**
* Solves a set of linear equations. The input parameters "matrix1",
* and "row_perm" come from luDecompostionD3x3 and do not change
* here. The parameter "matrix2" is a set of column vectors assembled
* into a 3x3 matrix of floating-point values. The procedure takes each
* column of "matrix2" in turn and treats it as the right-hand side of the
* matrix equation Ax = LUx = b. The solution vector replaces the
* original column of the matrix.
*
* If "matrix2" is the identity matrix, the procedure replaces its contents
* with the inverse of the matrix from which "matrix1" was originally
* derived.
*/
//
// Reference: Press, Flannery, Teukolsky, Vetterling,
// _Numerical_Recipes_in_C_, Cambridge University Press,
// 1988, pp 44-45.
//
static void luBacksubstitution(double[] matrix1,
int[] row_perm,
double[] matrix2) {
int i, ii, ip, j, k;
int rp;
int cv, rv;
// rp = row_perm;
rp = 0;
// For each column vector of matrix2 ...
for (k = 0; k < 3; k++) {
// cv = &(matrix2[0][k]);
cv = k;
ii = -1;
// Forward substitution
for (i = 0; i < 3; i++) {
double sum;
ip = row_perm[rp+i];
sum = matrix2[cv+3*ip];
matrix2[cv+3*ip] = matrix2[cv+3*i];
if (ii >= 0) {
// rv = &(matrix1[i][0]);
rv = i*3;
for (j = ii; j <= i-1; j++) {
sum -= matrix1[rv+j] * matrix2[cv+3*j];
}
}
else if (sum != 0.0) {
ii = i;
}
matrix2[cv+3*i] = sum;
}
// Backsubstitution
// rv = &(matrix1[3][0]);
rv = 2*3;
matrix2[cv+3*2] /= matrix1[rv+2];
rv -= 3;
matrix2[cv+3*1] = (matrix2[cv+3*1] -
matrix1[rv+2] * matrix2[cv+3*2]) / matrix1[rv+1];
rv -= 3;
matrix2[cv+4*0] = (matrix2[cv+3*0] -
matrix1[rv+1] * matrix2[cv+3*1] -
matrix1[rv+2] * matrix2[cv+3*2]) / matrix1[rv+0];
}
}
/**
* Computes the determinant of this matrix.
* @return the determinant of the matrix
*/
public final double determinant()
{
double total;
total = this.m00*(this.m11*this.m22 - this.m12*this.m21)
+ this.m01*(this.m12*this.m20 - this.m10*this.m22)
+ this.m02*(this.m10*this.m21 - this.m11*this.m20);
return total;
}
/**
* Sets the value of this matrix to a scale matrix with
* the passed scale amount.
* @param scale the scale factor for the matrix
*/
public final void set(double scale)
{
this.m00 = scale;
this.m01 = 0.0;
this.m02 = 0.0;
this.m10 = 0.0;
this.m11 = scale;
this.m12 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = scale;
}
/**
* Sets the value of this matrix to a counter clockwise rotation
* about the x axis.
* @param angle the angle to rotate about the X axis in radians
*/
public final void rotX(double angle)
{
double sinAngle, cosAngle;
sinAngle = Math.sin(angle);
cosAngle = Math.cos(angle);
this.m00 = 1.0;
this.m01 = 0.0;
this.m02 = 0.0;
this.m10 = 0.0;
this.m11 = cosAngle;
this.m12 = -sinAngle;
this.m20 = 0.0;
this.m21 = sinAngle;
this.m22 = cosAngle;
}
/**
* Sets the value of this matrix to a counter clockwise rotation
* about the y axis.
* @param angle the angle to rotate about the Y axis in radians
*/
public final void rotY(double angle)
{
double sinAngle, cosAngle;
sinAngle = Math.sin(angle);
cosAngle = Math.cos(angle);
this.m00 = cosAngle;
this.m01 = 0.0;
this.m02 = sinAngle;
this.m10 = 0.0;
this.m11 = 1.0;
this.m12 = 0.0;
this.m20 = -sinAngle;
this.m21 = 0.0;
this.m22 = cosAngle;
}
/**
* Sets the value of this matrix to a counter clockwise rotation
* about the z axis.
* @param angle the angle to rotate about the Z axis in radians
*/
public final void rotZ(double angle)
{
double sinAngle, cosAngle;
sinAngle = Math.sin(angle);
cosAngle = Math.cos(angle);
this.m00 = cosAngle;
this.m01 = -sinAngle;
this.m02 = 0.0;
this.m10 = sinAngle;
this.m11 = cosAngle;
this.m12 = 0.0;
this.m20 = 0.0;
this.m21 = 0.0;
this.m22 = 1.0;
}
/**
* Multiplies each element of this matrix by a scalar.
* @param scalar The scalar multiplier.
*/
public final void mul(double scalar)
{
m00 *= scalar;
m01 *= scalar;
m02 *= scalar;
m10 *= scalar;
m11 *= scalar;
m12 *= scalar;
m20 *= scalar;
m21 *= scalar;
m22 *= scalar;
}
/**
* Multiplies each element of matrix m1 by a scalar and places
* the result into this. Matrix m1 is not modified.
* @param scalar the scalar multiplier
* @param m1 the original matrix
*/
public final void mul(double scalar, Matrix3d m1)
{
this.m00 = scalar * m1.m00;
this.m01 = scalar * m1.m01;
this.m02 = scalar * m1.m02;
this.m10 = scalar * m1.m10;
this.m11 = scalar * m1.m11;
this.m12 = scalar * m1.m12;
this.m20 = scalar * m1.m20;
this.m21 = scalar * m1.m21;
this.m22 = scalar * m1.m22;
}
/**
* Sets the value of this matrix to the result of multiplying itself
* with matrix m1.
* @param m1 the other matrix
*/
public final void mul(Matrix3d m1)
{
double m00, m01, m02,
m10, m11, m12,
m20, m21, m22;
m00 = this.m00*m1.m00 + this.m01*m1.m10 + this.m02*m1.m20;
m01 = this.m00*m1.m01 + this.m01*m1.m11 + this.m02*m1.m21;
m02 = this.m00*m1.m02 + this.m01*m1.m12 + this.m02*m1.m22;
m10 = this.m10*m1.m00 + this.m11*m1.m10 + this.m12*m1.m20;
m11 = this.m10*m1.m01 + this.m11*m1.m11 + this.m12*m1.m21;
m12 = this.m10*m1.m02 + this.m11*m1.m12 + this.m12*m1.m22;
m20 = this.m20*m1.m00 + this.m21*m1.m10 + this.m22*m1.m20;
m21 = this.m20*m1.m01 + this.m21*m1.m11 + this.m22*m1.m21;
m22 = this.m20*m1.m02 + this.m21*m1.m12 + this.m22*m1.m22;
this.m00 = m00; this.m01 = m01; this.m02 = m02;
this.m10 = m10; this.m11 = m11; this.m12 = m12;
this.m20 = m20; this.m21 = m21; this.m22 = m22;
}
/**
* Sets the value of this matrix to the result of multiplying
* the two argument matrices together.
* @param m1 the first matrix
* @param m2 the second matrix
*/
public final void mul(Matrix3d m1, Matrix3d m2)
{
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20;
this.m01 = m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21;
this.m02 = m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22;
this.m10 = m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20;
this.m11 = m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21;
this.m12 = m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22;
this.m20 = m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20;
this.m21 = m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21;
this.m22 = m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22;
} else {
double m00, m01, m02,
m10, m11, m12,
m20, m21, m22; // vars for temp result matrix
m00 = m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20;
m01 = m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21;
m02 = m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22;
m10 = m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20;
m11 = m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21;
m12 = m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22;
m20 = m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20;
m21 = m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21;
m22 = m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22;
this.m00 = m00; this.m01 = m01; this.m02 = m02;
this.m10 = m10; this.m11 = m11; this.m12 = m12;
this.m20 = m20; this.m21 = m21; this.m22 = m22;
}
}
/**
* Multiplies this matrix by matrix m1, does an SVD normalization
* of the result, and places the result back into this matrix
* this = SVDnorm(this*m1).
* @param m1 the matrix on the right hand side of the multiplication
*/
public final void mulNormalize(Matrix3d m1){
double[] tmp = new double[9]; // scratch matrix
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
tmp[0] = this.m00*m1.m00 + this.m01*m1.m10 + this.m02*m1.m20;
tmp[1] = this.m00*m1.m01 + this.m01*m1.m11 + this.m02*m1.m21;
tmp[2] = this.m00*m1.m02 + this.m01*m1.m12 + this.m02*m1.m22;
tmp[3] = this.m10*m1.m00 + this.m11*m1.m10 + this.m12*m1.m20;
tmp[4] = this.m10*m1.m01 + this.m11*m1.m11 + this.m12*m1.m21;
tmp[5] = this.m10*m1.m02 + this.m11*m1.m12 + this.m12*m1.m22;
tmp[6] = this.m20*m1.m00 + this.m21*m1.m10 + this.m22*m1.m20;
tmp[7] = this.m20*m1.m01 + this.m21*m1.m11 + this.m22*m1.m21;
tmp[8] = this.m20*m1.m02 + this.m21*m1.m12 + this.m22*m1.m22;
compute_svd( tmp, tmp_scale, tmp_rot);
this.m00 = tmp_rot[0];
this.m01 = tmp_rot[1];
this.m02 = tmp_rot[2];
this.m10 = tmp_rot[3];
this.m11 = tmp_rot[4];
this.m12 = tmp_rot[5];
this.m20 = tmp_rot[6];
this.m21 = tmp_rot[7];
this.m22 = tmp_rot[8];
}
/**
* Multiplies matrix m1 by matrix m2, does an SVD normalization
* of the result, and places the result into this matrix
* this = SVDnorm(m1*m2).
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulNormalize(Matrix3d m1, Matrix3d m2){
double[] tmp = new double[9]; // scratch matrix
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
tmp[0] = m1.m00*m2.m00 + m1.m01*m2.m10 + m1.m02*m2.m20;
tmp[1] = m1.m00*m2.m01 + m1.m01*m2.m11 + m1.m02*m2.m21;
tmp[2] = m1.m00*m2.m02 + m1.m01*m2.m12 + m1.m02*m2.m22;
tmp[3] = m1.m10*m2.m00 + m1.m11*m2.m10 + m1.m12*m2.m20;
tmp[4] = m1.m10*m2.m01 + m1.m11*m2.m11 + m1.m12*m2.m21;
tmp[5] = m1.m10*m2.m02 + m1.m11*m2.m12 + m1.m12*m2.m22;
tmp[6] = m1.m20*m2.m00 + m1.m21*m2.m10 + m1.m22*m2.m20;
tmp[7] = m1.m20*m2.m01 + m1.m21*m2.m11 + m1.m22*m2.m21;
tmp[8] = m1.m20*m2.m02 + m1.m21*m2.m12 + m1.m22*m2.m22;
compute_svd( tmp, tmp_scale, tmp_rot);
this.m00 = tmp_rot[0];
this.m01 = tmp_rot[1];
this.m02 = tmp_rot[2];
this.m10 = tmp_rot[3];
this.m11 = tmp_rot[4];
this.m12 = tmp_rot[5];
this.m20 = tmp_rot[6];
this.m21 = tmp_rot[7];
this.m22 = tmp_rot[8];
}
/**
* Multiplies the transpose of matrix m1 times the transpose of matrix
* m2, and places the result into this.
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulTransposeBoth(Matrix3d m1, Matrix3d m2)
{
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m10*m2.m01 + m1.m20*m2.m02;
this.m01 = m1.m00*m2.m10 + m1.m10*m2.m11 + m1.m20*m2.m12;
this.m02 = m1.m00*m2.m20 + m1.m10*m2.m21 + m1.m20*m2.m22;
this.m10 = m1.m01*m2.m00 + m1.m11*m2.m01 + m1.m21*m2.m02;
this.m11 = m1.m01*m2.m10 + m1.m11*m2.m11 + m1.m21*m2.m12;
this.m12 = m1.m01*m2.m20 + m1.m11*m2.m21 + m1.m21*m2.m22;
this.m20 = m1.m02*m2.m00 + m1.m12*m2.m01 + m1.m22*m2.m02;
this.m21 = m1.m02*m2.m10 + m1.m12*m2.m11 + m1.m22*m2.m12;
this.m22 = m1.m02*m2.m20 + m1.m12*m2.m21 + m1.m22*m2.m22;
} else {
double m00, m01, m02,
m10, m11, m12,
m20, m21, m22; // vars for temp result matrix
m00 = m1.m00*m2.m00 + m1.m10*m2.m01 + m1.m20*m2.m02;
m01 = m1.m00*m2.m10 + m1.m10*m2.m11 + m1.m20*m2.m12;
m02 = m1.m00*m2.m20 + m1.m10*m2.m21 + m1.m20*m2.m22;
m10 = m1.m01*m2.m00 + m1.m11*m2.m01 + m1.m21*m2.m02;
m11 = m1.m01*m2.m10 + m1.m11*m2.m11 + m1.m21*m2.m12;
m12 = m1.m01*m2.m20 + m1.m11*m2.m21 + m1.m21*m2.m22;
m20 = m1.m02*m2.m00 + m1.m12*m2.m01 + m1.m22*m2.m02;
m21 = m1.m02*m2.m10 + m1.m12*m2.m11 + m1.m22*m2.m12;
m22 = m1.m02*m2.m20 + m1.m12*m2.m21 + m1.m22*m2.m22;
this.m00 = m00; this.m01 = m01; this.m02 = m02;
this.m10 = m10; this.m11 = m11; this.m12 = m12;
this.m20 = m20; this.m21 = m21; this.m22 = m22;
}
}
/**
* Multiplies matrix m1 times the transpose of matrix m2, and
* places the result into this.
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulTransposeRight(Matrix3d m1, Matrix3d m2)
{
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m01*m2.m01 + m1.m02*m2.m02;
this.m01 = m1.m00*m2.m10 + m1.m01*m2.m11 + m1.m02*m2.m12;
this.m02 = m1.m00*m2.m20 + m1.m01*m2.m21 + m1.m02*m2.m22;
this.m10 = m1.m10*m2.m00 + m1.m11*m2.m01 + m1.m12*m2.m02;
this.m11 = m1.m10*m2.m10 + m1.m11*m2.m11 + m1.m12*m2.m12;
this.m12 = m1.m10*m2.m20 + m1.m11*m2.m21 + m1.m12*m2.m22;
this.m20 = m1.m20*m2.m00 + m1.m21*m2.m01 + m1.m22*m2.m02;
this.m21 = m1.m20*m2.m10 + m1.m21*m2.m11 + m1.m22*m2.m12;
this.m22 = m1.m20*m2.m20 + m1.m21*m2.m21 + m1.m22*m2.m22;
} else {
double m00, m01, m02,
m10, m11, m12,
m20, m21, m22; // vars for temp result matrix
m00 = m1.m00*m2.m00 + m1.m01*m2.m01 + m1.m02*m2.m02;
m01 = m1.m00*m2.m10 + m1.m01*m2.m11 + m1.m02*m2.m12;
m02 = m1.m00*m2.m20 + m1.m01*m2.m21 + m1.m02*m2.m22;
m10 = m1.m10*m2.m00 + m1.m11*m2.m01 + m1.m12*m2.m02;
m11 = m1.m10*m2.m10 + m1.m11*m2.m11 + m1.m12*m2.m12;
m12 = m1.m10*m2.m20 + m1.m11*m2.m21 + m1.m12*m2.m22;
m20 = m1.m20*m2.m00 + m1.m21*m2.m01 + m1.m22*m2.m02;
m21 = m1.m20*m2.m10 + m1.m21*m2.m11 + m1.m22*m2.m12;
m22 = m1.m20*m2.m20 + m1.m21*m2.m21 + m1.m22*m2.m22;
this.m00 = m00; this.m01 = m01; this.m02 = m02;
this.m10 = m10; this.m11 = m11; this.m12 = m12;
this.m20 = m20; this.m21 = m21; this.m22 = m22;
}
}
/**
* Multiplies the transpose of matrix m1 times matrix m2, and
* places the result into this.
* @param m1 the matrix on the left hand side of the multiplication
* @param m2 the matrix on the right hand side of the multiplication
*/
public final void mulTransposeLeft(Matrix3d m1, Matrix3d m2) {
if (this != m1 && this != m2) {
this.m00 = m1.m00*m2.m00 + m1.m10*m2.m10 + m1.m20*m2.m20;
this.m01 = m1.m00*m2.m01 + m1.m10*m2.m11 + m1.m20*m2.m21;
this.m02 = m1.m00*m2.m02 + m1.m10*m2.m12 + m1.m20*m2.m22;
this.m10 = m1.m01*m2.m00 + m1.m11*m2.m10 + m1.m21*m2.m20;
this.m11 = m1.m01*m2.m01 + m1.m11*m2.m11 + m1.m21*m2.m21;
this.m12 = m1.m01*m2.m02 + m1.m11*m2.m12 + m1.m21*m2.m22;
this.m20 = m1.m02*m2.m00 + m1.m12*m2.m10 + m1.m22*m2.m20;
this.m21 = m1.m02*m2.m01 + m1.m12*m2.m11 + m1.m22*m2.m21;
this.m22 = m1.m02*m2.m02 + m1.m12*m2.m12 + m1.m22*m2.m22;
} else {
double m00, m01, m02,
m10, m11, m12,
m20, m21, m22; // vars for temp result matrix
m00 = m1.m00*m2.m00 + m1.m10*m2.m10 + m1.m20*m2.m20;
m01 = m1.m00*m2.m01 + m1.m10*m2.m11 + m1.m20*m2.m21;
m02 = m1.m00*m2.m02 + m1.m10*m2.m12 + m1.m20*m2.m22;
m10 = m1.m01*m2.m00 + m1.m11*m2.m10 + m1.m21*m2.m20;
m11 = m1.m01*m2.m01 + m1.m11*m2.m11 + m1.m21*m2.m21;
m12 = m1.m01*m2.m02 + m1.m11*m2.m12 + m1.m21*m2.m22;
m20 = m1.m02*m2.m00 + m1.m12*m2.m10 + m1.m22*m2.m20;
m21 = m1.m02*m2.m01 + m1.m12*m2.m11 + m1.m22*m2.m21;
m22 = m1.m02*m2.m02 + m1.m12*m2.m12 + m1.m22*m2.m22;
this.m00 = m00; this.m01 = m01; this.m02 = m02;
this.m10 = m10; this.m11 = m11; this.m12 = m12;
this.m20 = m20; this.m21 = m21; this.m22 = m22;
}
}
/**
* Performs singular value decomposition normalization of this matrix.
*/
public final void normalize(){
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
getScaleRotate( tmp_scale, tmp_rot );
this.m00 = tmp_rot[0];
this.m01 = tmp_rot[1];
this.m02 = tmp_rot[2];
this.m10 = tmp_rot[3];
this.m11 = tmp_rot[4];
this.m12 = tmp_rot[5];
this.m20 = tmp_rot[6];
this.m21 = tmp_rot[7];
this.m22 = tmp_rot[8];
}
/**
* Perform singular value decomposition normalization of matrix m1 and
* place the normalized values into this.
* @param m1 Provides the matrix values to be normalized
*/
public final void normalize(Matrix3d m1){
double[] tmp = new double[9]; // scratch matrix
double[] tmp_rot = new double[9]; // scratch matrix
double[] tmp_scale = new double[3]; // scratch matrix
tmp[0] = m1.m00;
tmp[1] = m1.m01;
tmp[2] = m1.m02;
tmp[3] = m1.m10;
tmp[4] = m1.m11;
tmp[5] = m1.m12;
tmp[6] = m1.m20;
tmp[7] = m1.m21;
tmp[8] = m1.m22;
compute_svd( tmp, tmp_scale, tmp_rot);
this.m00 = tmp_rot[0];
this.m01 = tmp_rot[1];
this.m02 = tmp_rot[2];
this.m10 = tmp_rot[3];
this.m11 = tmp_rot[4];
this.m12 = tmp_rot[5];
this.m20 = tmp_rot[6];
this.m21 = tmp_rot[7];
this.m22 = tmp_rot[8];
}
/**
* Perform cross product normalization of this matrix.
*/
public final void normalizeCP()
{
double mag = 1.0/Math.sqrt(m00*m00 + m10*m10 + m20*m20);
m00 = m00*mag;
m10 = m10*mag;
m20 = m20*mag;
mag = 1.0/Math.sqrt(m01*m01 + m11*m11 + m21*m21);
m01 = m01*mag;
m11 = m11*mag;
m21 = m21*mag;
m02 = m10*m21 - m11*m20;
m12 = m01*m20 - m00*m21;
m22 = m00*m11 - m01*m10;
}
/**
* Perform cross product normalization of matrix m1 and place the
* normalized values into this.
* @param m1 Provides the matrix values to be normalized
*/
public final void normalizeCP(Matrix3d m1)
{
double mag = 1.0/Math.sqrt(m1.m00*m1.m00 + m1.m10*m1.m10 + m1.m20*m1.m20);
m00 = m1.m00*mag;
m10 = m1.m10*mag;
m20 = m1.m20*mag;
mag = 1.0/Math.sqrt(m1.m01*m1.m01 + m1.m11*m1.m11 + m1.m21*m1.m21);
m01 = m1.m01*mag;
m11 = m1.m11*mag;
m21 = m1.m21*mag;
m02 = m10*m21 - m11*m20;
m12 = m01*m20 - m00*m21;
m22 = m00*m11 - m01*m10;
}
/**
* Returns true if all of the data members of Matrix3d m1 are
* equal to the corresponding data members in this Matrix3d.
* @param m1 the matrix with which the comparison is made
* @return true or false
*/
public boolean equals(Matrix3d m1)
{
try {
return(this.m00 == m1.m00 && this.m01 == m1.m01 && this.m02 == m1.m02
&& this.m10 == m1.m10 && this.m11 == m1.m11 && this.m12 == m1.m12
&& this.m20 == m1.m20 && this.m21 == m1.m21 && this.m22 == m1.m22);
}
catch (NullPointerException e2) { return false; }
}
/**
* Returns true if the Object t1 is of type Matrix3d and all of the
* data members of t1 are equal to the corresponding data members in
* this Matrix3d.
* @param t1 the matrix with which the comparison is made
* @return true or false
*/
public boolean equals(Object t1)
{
try {
Matrix3d m2 = (Matrix3d) t1;
return(this.m00 == m2.m00 && this.m01 == m2.m01 && this.m02 == m2.m02
&& this.m10 == m2.m10 && this.m11 == m2.m11 && this.m12 == m2.m12
&& this.m20 == m2.m20 && this.m21 == m2.m21 && this.m22 == m2.m22);
}
catch (ClassCastException e1) { return false; }
catch (NullPointerException e2) { return false; }
}
/**
* Returns true if the L-infinite distance between this matrix
* and matrix m1 is less than or equal to the epsilon parameter,
* otherwise returns false. The L-infinite
* distance is equal to
* MAX[i=0,1,2 ; j=0,1,2 ; abs(this.m(i,j) - m1.m(i,j)]
* @param m1 the matrix to be compared to this matrix
* @param epsilon the threshold value
*/
public boolean epsilonEquals(Matrix3d m1, double epsilon)
{
double diff;
diff = m00 - m1.m00;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m01 - m1.m01;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m02 - m1.m02;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m10 - m1.m10;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m11 - m1.m11;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m12 - m1.m12;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m20 - m1.m20;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m21 - m1.m21;
if((diff<0?-diff:diff) > epsilon) return false;
diff = m22 - m1.m22;
if((diff<0?-diff:diff) > epsilon) return false;
return true;
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Matrix3d objects with identical data values
* (i.e., Matrix3d.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
long bits = 1L;
bits = 31L * bits + VecMathUtil.doubleToLongBits(m00);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m01);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m02);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m10);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m11);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m12);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m20);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m21);
bits = 31L * bits + VecMathUtil.doubleToLongBits(m22);
return (int) (bits ^ (bits >> 32));
}
/**
* Sets this matrix to all zeros.
*/
public final void setZero()
{
m00 = 0.0;
m01 = 0.0;
m02 = 0.0;
m10 = 0.0;
m11 = 0.0;
m12 = 0.0;
m20 = 0.0;
m21 = 0.0;
m22 = 0.0;
}
/**
* Negates the value of this matrix: this = -this.
*/
public final void negate()
{
this.m00 = -this.m00;
this.m01 = -this.m01;
this.m02 = -this.m02;
this.m10 = -this.m10;
this.m11 = -this.m11;
this.m12 = -this.m12;
this.m20 = -this.m20;
this.m21 = -this.m21;
this.m22 = -this.m22;
}
/**
* Sets the value of this matrix equal to the negation of
* of the Matrix3d parameter.
* @param m1 the source matrix
*/
public final void negate(Matrix3d m1)
{
this.m00 = -m1.m00;
this.m01 = -m1.m01;
this.m02 = -m1.m02;
this.m10 = -m1.m10;
this.m11 = -m1.m11;
this.m12 = -m1.m12;
this.m20 = -m1.m20;
this.m21 = -m1.m21;
this.m22 = -m1.m22;
}
/**
* Multiply this matrix by the tuple t and place the result
* back into the tuple (t = this*t).
* @param t the tuple to be multiplied by this matrix and then replaced
*/
public final void transform(Tuple3d t) {
double x,y,z;
x = m00* t.x + m01*t.y + m02*t.z;
y = m10* t.x + m11*t.y + m12*t.z;
z = m20* t.x + m21*t.y + m22*t.z;
t.set(x,y,z);
}
/**
* Multiply this matrix by the tuple t and and place the result
* into the tuple "result" (result = this*t).
* @param t the tuple to be multiplied by this matrix
* @param result the tuple into which the product is placed
*/
public final void transform(Tuple3d t, Tuple3d result) {
double x,y,z;
x = m00* t.x + m01*t.y + m02*t.z;
y = m10* t.x + m11*t.y + m12*t.z;
result.z = m20* t.x + m21*t.y + m22*t.z;
result.x = x;
result.y = y;
}
/**
* perform SVD (if necessary to get rotational component
*/
final void getScaleRotate(double scales[], double rots[]) {
double[] tmp = new double[9]; // scratch matrix
tmp[0] = m00;
tmp[1] = m01;
tmp[2] = m02;
tmp[3] = m10;
tmp[4] = m11;
tmp[5] = m12;
tmp[6] = m20;
tmp[7] = m21;
tmp[8] = m22;
compute_svd( tmp, scales, rots);
return;
}
static void compute_svd( double[] m, double[] outScale, double[] outRot) {
int i,j;
double g,scale;
double[] u1 = new double[9];
double[] v1 = new double[9];
double[] t1 = new double[9];
double[] t2 = new double[9];
double[] tmp = t1;
double[] single_values = t2;
double[] rot = new double[9];
double[] e = new double[3];
double[] scales = new double[3];
int converged, negCnt=0;
double cs,sn;
double c1,c2,c3,c4;
double s1,s2,s3,s4;
double cl1,cl2,cl3;
for(i=0; i<9; i++)
rot[i] = m[i];
// u1
if( m[3]*m[3] < EPS ) {
u1[0] = 1.0; u1[1] = 0.0; u1[2] = 0.0;
u1[3] = 0.0; u1[4] = 1.0; u1[5] = 0.0;
u1[6] = 0.0; u1[7] = 0.0; u1[8] = 1.0;
} else if( m[0]*m[0] < EPS ) {
tmp[0] = m[0];
tmp[1] = m[1];
tmp[2] = m[2];
m[0] = m[3];
m[1] = m[4];
m[2] = m[5];
m[3] = -tmp[0]; // zero
m[4] = -tmp[1];
m[5] = -tmp[2];
u1[0] = 0.0; u1[1] = 1.0; u1[2] = 0.0;
u1[3] = -1.0; u1[4] = 0.0; u1[5] = 0.0;
u1[6] = 0.0; u1[7] = 0.0; u1[8] = 1.0;
} else {
g = 1.0/Math.sqrt(m[0]*m[0] + m[3]*m[3]);
c1 = m[0]*g;
s1 = m[3]*g;
tmp[0] = c1*m[0] + s1*m[3];
tmp[1] = c1*m[1] + s1*m[4];
tmp[2] = c1*m[2] + s1*m[5];
m[3] = -s1*m[0] + c1*m[3]; // zero
m[4] = -s1*m[1] + c1*m[4];
m[5] = -s1*m[2] + c1*m[5];
m[0] = tmp[0];
m[1] = tmp[1];
m[2] = tmp[2];
u1[0] = c1; u1[1] = s1; u1[2] = 0.0;
u1[3] = -s1; u1[4] = c1; u1[5] = 0.0;
u1[6] = 0.0; u1[7] = 0.0; u1[8] = 1.0;
}
// u2
if( m[6]*m[6] < EPS ) {
} else if( m[0]*m[0] < EPS ){
tmp[0] = m[0];
tmp[1] = m[1];
tmp[2] = m[2];
m[0] = m[6];
m[1] = m[7];
m[2] = m[8];
m[6] = -tmp[0]; // zero
m[7] = -tmp[1];
m[8] = -tmp[2];
tmp[0] = u1[0];
tmp[1] = u1[1];
tmp[2] = u1[2];
u1[0] = u1[6];
u1[1] = u1[7];
u1[2] = u1[8];
u1[6] = -tmp[0]; // zero
u1[7] = -tmp[1];
u1[8] = -tmp[2];
} else {
g = 1.0/Math.sqrt(m[0]*m[0] + m[6]*m[6]);
c2 = m[0]*g;
s2 = m[6]*g;
tmp[0] = c2*m[0] + s2*m[6];
tmp[1] = c2*m[1] + s2*m[7];
tmp[2] = c2*m[2] + s2*m[8];
m[6] = -s2*m[0] + c2*m[6];
m[7] = -s2*m[1] + c2*m[7];
m[8] = -s2*m[2] + c2*m[8];
m[0] = tmp[0];
m[1] = tmp[1];
m[2] = tmp[2];
tmp[0] = c2*u1[0];
tmp[1] = c2*u1[1];
u1[2] = s2;
tmp[6] = -u1[0]*s2;
tmp[7] = -u1[1]*s2;
u1[8] = c2;
u1[0] = tmp[0];
u1[1] = tmp[1];
u1[6] = tmp[6];
u1[7] = tmp[7];
}
// v1
if( m[2]*m[2] < EPS ) {
v1[0] = 1.0; v1[1] = 0.0; v1[2] = 0.0;
v1[3] = 0.0; v1[4] = 1.0; v1[5] = 0.0;
v1[6] = 0.0; v1[7] = 0.0; v1[8] = 1.0;
} else if( m[1]*m[1] < EPS ) {
tmp[2] = m[2];
tmp[5] = m[5];
tmp[8] = m[8];
m[2] = -m[1];
m[5] = -m[4];
m[8] = -m[7];
m[1] = tmp[2]; // zero
m[4] = tmp[5];
m[7] = tmp[8];
v1[0] = 1.0; v1[1] = 0.0; v1[2] = 0.0;
v1[3] = 0.0; v1[4] = 0.0; v1[5] =-1.0;
v1[6] = 0.0; v1[7] = 1.0; v1[8] = 0.0;
} else {
g = 1.0/Math.sqrt(m[1]*m[1] + m[2]*m[2]);
c3 = m[1]*g;
s3 = m[2]*g;
tmp[1] = c3*m[1] + s3*m[2]; // can assign to m[1]?
m[2] =-s3*m[1] + c3*m[2]; // zero
m[1] = tmp[1];
tmp[4] = c3*m[4] + s3*m[5];
m[5] =-s3*m[4] + c3*m[5];
m[4] = tmp[4];
tmp[7] = c3*m[7] + s3*m[8];
m[8] =-s3*m[7] + c3*m[8];
m[7] = tmp[7];
v1[0] = 1.0; v1[1] = 0.0; v1[2] = 0.0;
v1[3] = 0.0; v1[4] = c3; v1[5] = -s3;
v1[6] = 0.0; v1[7] = s3; v1[8] = c3;
}
// u3
if( m[7]*m[7] < EPS ) {
} else if( m[4]*m[4] < EPS ) {
tmp[3] = m[3];
tmp[4] = m[4];
tmp[5] = m[5];
m[3] = m[6]; // zero
m[4] = m[7];
m[5] = m[8];
m[6] = -tmp[3]; // zero
m[7] = -tmp[4]; // zero
m[8] = -tmp[5];
tmp[3] = u1[3];
tmp[4] = u1[4];
tmp[5] = u1[5];
u1[3] = u1[6];
u1[4] = u1[7];
u1[5] = u1[8];
u1[6] = -tmp[3]; // zero
u1[7] = -tmp[4];
u1[8] = -tmp[5];
} else {
g = 1.0/Math.sqrt(m[4]*m[4] + m[7]*m[7]);
c4 = m[4]*g;
s4 = m[7]*g;
tmp[3] = c4*m[3] + s4*m[6];
m[6] =-s4*m[3] + c4*m[6]; // zero
m[3] = tmp[3];
tmp[4] = c4*m[4] + s4*m[7];
m[7] =-s4*m[4] + c4*m[7];
m[4] = tmp[4];
tmp[5] = c4*m[5] + s4*m[8];
m[8] =-s4*m[5] + c4*m[8];
m[5] = tmp[5];
tmp[3] = c4*u1[3] + s4*u1[6];
u1[6] =-s4*u1[3] + c4*u1[6];
u1[3] = tmp[3];
tmp[4] = c4*u1[4] + s4*u1[7];
u1[7] =-s4*u1[4] + c4*u1[7];
u1[4] = tmp[4];
tmp[5] = c4*u1[5] + s4*u1[8];
u1[8] =-s4*u1[5] + c4*u1[8];
u1[5] = tmp[5];
}
single_values[0] = m[0];
single_values[1] = m[4];
single_values[2] = m[8];
e[0] = m[1];
e[1] = m[5];
if( e[0]*e[0]byteVariable = (byte) intValue; // intValue can be > 127
* If intValue is greater than 127, then byteVariable will be negative. The
* correct value will be extracted when it is used (by masking off the upper
* bits).
*/
public abstract class Tuple4b implements java.io.Serializable, Cloneable {
static final long serialVersionUID = -8226727741811898211L;
/**
* The first value.
*/
public byte x;
/**
* The second value.
*/
public byte y;
/**
* The third value.
*/
public byte z;
/**
* The fourth value.
*/
public byte w;
/**
* Constructs and initializes a Tuple4b from the specified four values.
* @param b1 the first value
* @param b2 the second value
* @param b3 the third value
* @param b4 the fourth value
*/
public Tuple4b(byte b1, byte b2, byte b3, byte b4)
{
this.x = b1;
this.y = b2;
this.z = b3;
this.w = b4;
}
/**
* Constructs and initializes a Tuple4b from the array of length 4.
* @param t the array of length 4 containing b1 b2 b3 b4 in order
*/
public Tuple4b(byte[] t)
{
this.x = t[0];
this.y = t[1];
this.z = t[2];
this.w = t[3];
}
/**
* Constructs and initializes a Tuple4b from the specified Tuple4b.
* @param t1 the Tuple4b containing the initialization x y z w data
*/
public Tuple4b(Tuple4b t1)
{
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = t1.w;
}
/**
* Constructs and initializes a Tuple4b to (0,0,0,0).
*/
public Tuple4b()
{
this.x = (byte) 0;
this.y = (byte) 0;
this.z = (byte) 0;
this.w = (byte) 0;
}
/**
* Returns a string that contains the values of this Tuple4b.
* @return the String representation
*/
public String toString()
{
return("(" + ((int)this.x & 0xff) +
", " + ((int)this.y & 0xff) +
", " + ((int)this.z & 0xff) +
", " + ((int)this.w & 0xff) + ")");
}
/**
* Places the value of the x,y,z,w components of this Tuple4b
* into the array of length 4.
* @param b array of length 4 into which the values are placed
*/
public final void get(byte[] b)
{
b[0] = this.x;
b[1] = this.y;
b[2] = this.z;
b[3] = this.w;
}
/**
* Places the value of the x,y,z,w components of this
* Tuple4b into the tuple t1.
* @param t1 tuple into which the values are placed
*/
public final void get(Tuple4b t1)
{
t1.x = this.x;
t1.y = this.y;
t1.z = this.z;
t1.w = this.w;
}
/**
* Sets the value of the data members of this tuple to the value
* of the argument tuple t1.
* @param t1 the source tuple
*/
public final void set(Tuple4b t1)
{
this.x = t1.x;
this.y = t1.y;
this.z = t1.z;
this.w = t1.w;
}
/**
* Sets the value of the data members of this tuple to the value
* of the array b of length 4.
* @param b the source array of length 4
*/
public final void set(byte[] b)
{
this.x = b[0];
this.y = b[1];
this.z = b[2];
this.w = b[3];
}
/**
* Returns true if all of the data members of tuple t1 are equal to
* the corresponding data members in this tuple.
* @param t1 the tuple with which the comparison is made
*/
public boolean equals(Tuple4b t1)
{
try {
return(this.x == t1.x && this.y == t1.y &&
this.z == t1.z && this.w == t1.w);
}
catch (NullPointerException e2) {return false;}
}
/**
* Returns true if the Object t1 is of type Tuple4b and all of the
* data members of t1 are equal to the corresponding data members in
* this Tuple4b.
* @param t1 the object with which the comparison is made
*/
public boolean equals(Object t1)
{
try {
Tuple4b t2 = (Tuple4b) t1;
return(this.x == t2.x && this.y == t2.y &&
this.z == t2.z && this.w == t2.w);
}
catch (NullPointerException e2) {return false;}
catch (ClassCastException e1) {return false;}
}
/**
* Returns a hash code value based on the data values in this
* object. Two different Tuple4b objects with identical data values
* (i.e., Tuple4b.equals returns true) will return the same hash
* code value. Two objects with different data members may return the
* same hash value, although this is not likely.
* @return the integer hash code value
*/
public int hashCode() {
return ((((int)x & 0xff) << 0) |
(((int)y & 0xff) << 8) |
(((int)z & 0xff) << 16) |
(((int)w & 0xff) << 24));
}
/**
* Creates a new object of the same class as this object.
*
* @return a clone of this instance.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since vecmath 1.3
*/
public Object clone() {
// Since there are no arrays we can just use Object.clone()
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
/**
* Get x, the first value.
*
* @return Returns x, the first value.
*
* @since vecmath 1.5
*/
public final byte getX() {
return x;
}
/**
* Set x, the first value.
*
* @param x the first value.
*
* @since vecmath 1.5
*/
public final void setX(byte x) {
this.x = x;
}
/**
* Get y, the second value.
*
* @return Returns y, the second value.
*
* @since vecmath 1.5
*/
public final byte getY() {
return y;
}
/**
* Set y, the second value.
*
* @param y the second value.
*
* @since vecmath 1.5
*/
public final void setY(byte y) {
this.y = y;
}
/**
* Get z, the third value.
*
* @return Returns z, the third value.
*
* @since vecmath 1.5
*/
public final byte getZ() {
return z;
}
/**
* Set z, the third value.
*
* @param z the third value.
*
* @since vecmath 1.5
*/
public final void setZ(byte z) {
this.z = z;
}
/**
* Get w, the fourth value.
*
* @return Returns w - the fourth value.
*
* @since vecmath 1.5
*/
public final byte getW() {
return w;
}
/**
* Set w, the fourth value.
*
* @param w the fourth value.
*
* @since vecmath 1.5
*/
public final void setW(byte w) {
this.w = w;
}
}
source-cvs/vecmath/src/javax/vecmath/Point3f.java 0000644 0001750 0001750 00000011636 10761613452 021402 0 ustar jonny jonny /*
* $RCSfile: Point3f.java,v $
*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* $Revision: 1.5 $
* $Date: 2008/02/28 20:18:50 $
* $State: Exp $
*/
package javax.vecmath;
import java.lang.Math;
/**
* A 3 element point that is represented by single precision floating point
* x,y,z coordinates.
*
*/
public class Point3f extends Tuple3f implements java.io.Serializable {
// Compatible with 1.1
static final long serialVersionUID = -8689337816398030143L;
/**
* Constructs and initializes a Point3f from the specified xyz coordinates.
* @param x the x coordinate
* @param y the y coordinate
* @param z the z coordinate
*/
public Point3f(float x, float y, float z)
{
super(x,y,z);
}
/**
* Constructs and initializes a Point3f from the array of length 3.
* @param p the array of length 3 containing xyz in order
*/
public Point3f(float[] p)
{
super(p);
}
/**
* Constructs and initializes a Point3f from the specified Point3f.
* @param p1 the Point3f containing the initialization x y z data
*/
public Point3f(Point3f p1)
{
super(p1);
}
/**
* Constructs and initializes a Point3f from the specified Point3d.
* @param p1 the Point3d containing the initialization x y z data
*/
public Point3f(Point3d p1)
{
super(p1);
}
/**
* Constructs and initializes a Point3f from the specified Tuple3f.
* @param t1 the Tuple3f containing the initialization x y z data
*/
public Point3f(Tuple3f t1)
{
super(t1);
}
/**
* Constructs and initializes a Point3f from the specified Tuple3d.
* @param t1 the Tuple3d containing the initialization x y z data
*/
public Point3f(Tuple3d t1)
{
super(t1);
}
/**
* Constructs and initializes a Point3f to (0,0,0).
*/
public Point3f()
{
super();
}
/**
* Computes the square of the distance between this point and
* point p1.
* @param p1 the other point
* @return the square of the distance
*/
public final float distanceSquared(Point3f p1)
{
float dx, dy, dz;
dx = this.x-p1.x;
dy = this.y-p1.y;
dz = this.z-p1.z;
return dx*dx+dy*dy+dz*dz;
}
/**
* Computes the distance between this point and point p1.
* @param p1 the other point
* @return the distance
*/
public final float distance(Point3f p1)
{
float dx, dy, dz;
dx = this.x-p1.x;
dy = this.y-p1.y;
dz = this.z-p1.z;
return (float) Math.sqrt(dx*dx+dy*dy+dz*dz);
}
/**
* Computes the L-1 (Manhattan) distance between this point and
* point p1. The L-1 distance is equal to:
* abs(x1-x2) + abs(y1-y2) + abs(z1-z2).
* @param p1 the other point
* @return the L-1 distance
*/
public final float distanceL1(Point3f p1)
{
return( Math.abs(this.x-p1.x) + Math.abs(this.y-p1.y) + Math.abs(this.z-p1.z));
}
/**
* Computes the L-infinite distance between this point and
* point p1. The L-infinite distance is equal to
* MAX[abs(x1-x2), abs(y1-y2), abs(z1-z2)].
* @param p1 the other point
* @return the L-infinite distance
*/
public final float distanceLinf(Point3f p1)
{
float tmp;
tmp = Math.max( Math.abs(this.x-p1.x), Math.abs(this.y-p1.y));
return(Math.max(tmp,Math.abs(this.z-p1.z)));
}
/**
* Multiplies each of the x,y,z components of the Point4f parameter
* by 1/w and places the projected values into this point.
* @param p1 the source Point4f, which is not modified
*/
public final void project(Point4f p1)
{
float oneOw;
oneOw = 1/p1.w;
x = p1.x*oneOw;
y = p1.y*oneOw;
z = p1.z*oneOw;
}
}
source-cvs/vecmath/src/javax/vecmath/package.html 0000644 0001750 0001750 00000000407 10330011523 021447 0 ustar jonny jonny
CVS download and build instructions for vecmath
cd <cvs-root-dir>
cvs checkout vecmath
Obsolete Page
Obsolete Page
javax.vecmath.
License
javax.vecmath package is licensed
under the GNU
Public License, version 2, with the Classpath Exception. This is the same
license that is used for the OpenJDK project.