gov.nasa.worldwind.geom
Class Vec4

java.lang.Object
  gov.nasa.worldwind.geom.Vec4

public class Vec4
extends Object

Field Summary

static Vec4	INFINITY
static Vec4	ONE
static Vec4	UNIT_NEGATIVE_W
static Vec4	UNIT_NEGATIVE_X
static Vec4	UNIT_NEGATIVE_Y
static Vec4	UNIT_NEGATIVE_Z
static Vec4	UNIT_W
static Vec4	UNIT_X
static Vec4	UNIT_Y
static Vec4	UNIT_Z
double	w
double	x
double	y
double	z
static Vec4	ZERO

Constructor Summary

Vec4(double value)

Vec4(double x, double y)

Vec4(double x, double y, double z)

Vec4(double x, double y, double z, double w)

Method Summary

Vec4	add3(double x, double y, double z)
Vec4	add3(Vec4 vec4)
Angle	angleBetween3(Vec4 vec4)
static boolean	areColinear(Vec4 a, Vec4 b, Vec4 c) Indicates whether three vectors are colinear.
static Angle	axisAngle(Vec4 v1, Vec4 v2, Vec4[] result) Compute the angle and rotation axis required to rotate one vector to align with another.
static Vec4	clamp3(Vec4 vec4, double min, double max)
static Vec4	computeAveragePoint(Iterable<? extends Vec4> points) Returns the arithmetic mean of the x, y, z, and w coordinates of the specified points Iterable.
static Vec4	computeAveragePoint3(BufferWrapper coordinates, int stride) Returns the arithmetic mean of the x, y, z coordinates of the specified points buffer.
static Vec4[]	computeExtrema(BufferWrapper buffer)
static Vec4[]	computeExtrema(Vec4[] points) Calculate the extrema of a given array of Vec4s.
Vec4	cross3(Vec4 vec4)
double	distanceTo2(Vec4 vec4)
double	distanceTo3(Vec4 vec4)
double	distanceToSquared3(Vec4 vec4)
Vec4	divide3(double value)
Vec4	divide3(Vec4 vec4)
double	dot3(Vec4 vec4)
double	dot4(Vec4 vec4)
double	dotSelf3()
double	dotSelf4()
boolean	equals(Object obj)
static Vec4	fromArray2(double[] array, int offset) Constructs a new Vec4 with x and y values from the specified double array.
static Vec4	fromArray3(double[] array, int offset) Constructs a new Vec4 with x, y and z values from the specified double array.
static Vec4	fromArray4(double[] array, int offset) Constructs a new Vec4 with x, y, z and w values from the specified double array.
static Vec4	fromDoubleArray(double[] array, int offset, int length) Constructs a new Vec4 with coordinate values read from the specified double array.
static Vec4	fromFloatArray(float[] array, int offset, int length) Constructs a new Vec4 with coordinate values read from the specified float array.
static Vec4	fromLine3(Vec4 origin, double t, Vec4 direction)
Vec4	getAbs3()
static double	getAverageDistance(Iterable<? extends Vec4> points)
double	getLength3()
double	getLengthSquared3()
Vec4	getNegative3()
double	getW()
double	getX()
double	getY()
double	getZ()
int	hashCode()
static Vec4	max3(Vec4 value1, Vec4 value2)
static Vec4	min3(Vec4 value1, Vec4 value2)
static Vec4	mix3(double amount, Vec4 value1, Vec4 value2)
Vec4	multiply3(double value)
Vec4	multiply3(Vec4 vec4)
Vec4	normalize3()
Vec4	perpendicularTo3(Vec4 vec4)
Vec4[]	perpendicularVectors() Computes two vectors mutually perpendicular to this vector and each other.
Vec4	projectOnto3(Vec4 vec4)
Vec4	subtract3(double x, double y, double z)
Vec4	subtract3(Vec4 vec4)
double[]	toArray2(double[] array, int offset) Writes this Vec4's x and y values to the specified double array.
double[]	toArray3(double[] array, int offset) Writes this Vec4's x, y and z values to the specified double array.
double[]	toArray4(double[] array, int offset) Writes this Vec4's x, y, z and w values to the specified double array.
double[]	toDoubleArray(double[] array, int offset, int length) Writes this Vec4's coordinate values to the specified double array.
float[]	toFloatArray(float[] array, int offset, int length) Writes this Vec4's coordinate values to the specified float array.
Vec4	toHomogeneousDirection3() Returns a representation of this vector as an x y z direction suitable for use where four-dimensional homogeneous coordinates are required.
Vec4	toHomogeneousPoint3() Returns a representation of this vector as an x y z point suitable for use where four-dimensional homogeneous coordinates are required.
String	toString()
Vec4	transformBy3(Matrix matrix)
Vec4	transformBy3(Quaternion quaternion)
Vec4	transformBy4(Matrix matrix)
double	w()
double	x()
double	y()
double	z()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

INFINITY

public static final Vec4 INFINITY

ONE

public static final Vec4 ONE

UNIT_NEGATIVE_W

public static final Vec4 UNIT_NEGATIVE_W

UNIT_NEGATIVE_X

public static final Vec4 UNIT_NEGATIVE_X

UNIT_NEGATIVE_Y

public static final Vec4 UNIT_NEGATIVE_Y

UNIT_NEGATIVE_Z

public static final Vec4 UNIT_NEGATIVE_Z

UNIT_W

public static final Vec4 UNIT_W

UNIT_X

public static final Vec4 UNIT_X

UNIT_Y

public static final Vec4 UNIT_Y

UNIT_Z

public static final Vec4 UNIT_Z

w

public final double w

x

public final double x

y

public final double y

z

public final double z

ZERO

public static final Vec4 ZERO

Constructor Detail

Vec4

public Vec4(double value)

Vec4

public Vec4(double x,
            double y)

Vec4

public Vec4(double x,
            double y,
            double z)

Vec4

public Vec4(double x,
            double y,
            double z,
            double w)

Method Detail

add3

public final Vec4 add3(double x,
                       double y,
                       double z)

add3

public final Vec4 add3(Vec4 vec4)

angleBetween3

public final Angle angleBetween3(Vec4 vec4)

areColinear

public static boolean areColinear(Vec4 a,
                                  Vec4 b,
                                  Vec4 c)

Indicates whether three vectors are colinear.

Parameters:

a - the first vector.

b - the second vector.

c - the third vector.

Returns:

true if the vectors are colinear, otherwise false.

Throws:

IllegalArgumentException - if any argument is null.

axisAngle

public static Angle axisAngle(Vec4 v1,
                              Vec4 v2,
                              Vec4[] result)

Compute the angle and rotation axis required to rotate one vector to align with another.

Parameters:

v1 - The base vector.

v2 - The vector to rotate into alignment with v1.

result - A reference to an array in which to return the computed axis. May not be null.

Returns:

The rotation angle.

Throws:

IllegalArgumentException - if any parameter is null.

clamp3

public static Vec4 clamp3(Vec4 vec4,
                          double min,
                          double max)

computeAveragePoint

public static Vec4 computeAveragePoint(Iterable<? extends Vec4> points)

Returns the arithmetic mean of the x, y, z, and w coordinates of the specified points Iterable. This returns null if the Iterable contains no points, or if all of the points are null.

Parameters:

points - the Iterable of points which define the returned arithmetic mean.

Returns:

the arithmetic mean point of the specified points Iterable, or null if the Iterable is empty or contains only null points.

Throws:

IllegalArgumentException - if the Iterable is null.

computeAveragePoint3

public static Vec4 computeAveragePoint3(BufferWrapper coordinates,
                                        int stride)

Returns the arithmetic mean of the x, y, z coordinates of the specified points buffer. This returns null if the buffer is empty.

The buffer must contain XYZ coordinate tuples which are either tightly packed or offset by the specified stride. The stride specifies the number of buffer elements between the first coordinate of consecutive tuples. For example, a stride of 3 specifies that each tuple is tightly packed as XYZXYZXYZ, whereas a stride of 5 specifies that there are two elements between each tuple as XYZabXYZab (the elements "a" and "b" are ignored). The stride must be at least 3. If the buffer's length is not evenly divisible into stride-sized tuples, this ignores the remaining elements that follow the last complete tuple.

Parameters:

coordinates - the buffer containing the point coordinates for which to compute a bounding volume.

stride - the number of elements between the first coordinate of consecutive points. If stride is 3, this interprets the buffer has having tightly packed XYZ coordinate tuples.

Returns:

the arithmetic mean point of the specified points Iterable, or null if the Iterable is empty or contains only null points.

Throws:

IllegalArgumentException - if the buffer is null, or if the stride is less than three.

computeExtrema

public static Vec4[] computeExtrema(BufferWrapper buffer)

computeExtrema

public static Vec4[] computeExtrema(Vec4[] points)

Calculate the extrema of a given array of Vec4s. The resulting array is always of length 2, with the first element containing the minimum extremum, and the second containing the maximum. The minimum extremum is composed by taking the smallest x, y and z values from all the Vec4s in the array. These values are not necessarily taken from the same Vec4. The maximum extrema is composed in the same fashion.

Parameters:

points - any array of Vec4s

Returns:

a array with length of 2, comprising the most extreme values in the given array

Throws:

IllegalArgumentException - if points is null

cross3

public final Vec4 cross3(Vec4 vec4)

distanceTo2

public final double distanceTo2(Vec4 vec4)

distanceTo3

public final double distanceTo3(Vec4 vec4)

distanceToSquared3

public final double distanceToSquared3(Vec4 vec4)

divide3

public final Vec4 divide3(double value)

divide3

public final Vec4 divide3(Vec4 vec4)

dot3

public final double dot3(Vec4 vec4)

dot4

public final double dot4(Vec4 vec4)

dotSelf3

public final double dotSelf3()

dotSelf4

public final double dotSelf4()

equals

public final boolean equals(Object obj)

Overrides:

equals in class Object

fromArray2

public static Vec4 fromArray2(double[] array,
                              int offset)

Constructs a new Vec4 with x and y values from the specified double array. The specified offset must be 0 or greater, and the array must have capacity equal to or greater than offset + 2. Coordinates are assigned as follows:

x = array[offset]
y = array[offset + 1]

Parameters:

array - the double array from which to read coordinate data.

offset - the array starting index.

Returns:

a new Vec4 with x and y coordinate values from the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, or if the array's capacity is less than offset + 2.

fromArray3

public static Vec4 fromArray3(double[] array,
                              int offset)

Constructs a new Vec4 with x, y and z values from the specified double array. The specified offset must be 0 or greater, and the array must have capacity equal to or greater than offset + 3. Coordinates are assigned as follows:

x = array[offset]
y = array[offset + 1]
z = array[offset + 2]

Parameters:

array - the double array from which to read coordinate data.

offset - the array starting index.

Returns:

a new Vec4 with x, y and z coordinate values from the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, or if the array's capacity is less than offset + 3.

fromArray4

public static Vec4 fromArray4(double[] array,
                              int offset)

Constructs a new Vec4 with x, y, z and w values from the specified double array. The specified offset must be 0 or greater, and the array must have capacity equal to or greater than offset + 4. Coordinates are assigned as follows:

x = array[offset]
y = array[offset + 1]
z = array[offset + 2]
w = array[offset + 3]

Parameters:

array - the double array from which to read coordinate data.

offset - the array starting index.

Returns:

a new Vec4 with x, y, z and w coordinate values from the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, or if the array's capacity is less than offset + 4.

fromDoubleArray

public static Vec4 fromDoubleArray(double[] array,
                                   int offset,
                                   int length)

Constructs a new Vec4 with coordinate values read from the specified double array. The specified offset must be 0 or greater, the specified length must be 1 or greater, and the array must have capacity equal to or greater than offset + length. Coordinates are assigned as follows:

x = array[offset]
y = array[offset + 1] if length > 1, otherwise y=0
z = array[offset + 2] if length > 2, otherwise z=0
w = array[offset + 3] if length > 3, otherwise w=1

Parameters:

array - the double array from which to read coordinate data.

offset - the array starting index.

length - the number of coordinates to read.

Returns:

a new Vec4 with coordinate values read from the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, if length is less than 1, or if the array's capacity is less than offset + length.

fromFloatArray

public static Vec4 fromFloatArray(float[] array,
                                  int offset,
                                  int length)

Constructs a new Vec4 with coordinate values read from the specified float array. The specified offset must be 0 or greater, the specified length must be 1 or greater, and the array must have capacity equal to or greater than offset + length. Coordinates are assigned as follows:

x = array[offset]
y = array[offset + 1] if length > 1, otherwise y=0
z = array[offset + 2] if length > 2, otherwise z=0
w = array[offset + 3] if length > 3, otherwise w=1

Parameters:

array - the float array from which to read coordinate data.

offset - the array starting index.

length - the number of coordinates to read.

Returns:

a new Vec4 with coordinate values read from the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, if length is less than 1, or if the array's capacity is less than offset + length.

fromLine3

public static Vec4 fromLine3(Vec4 origin,
                             double t,
                             Vec4 direction)

getAbs3

public final Vec4 getAbs3()

getAverageDistance

public static double getAverageDistance(Iterable<? extends Vec4> points)

getLength3

public final double getLength3()

getLengthSquared3

public final double getLengthSquared3()

getNegative3

public final Vec4 getNegative3()

getW

public final double getW()

getX

public final double getX()

getY

public final double getY()

getZ

public final double getZ()

hashCode

public final int hashCode()

Overrides:

hashCode in class Object

max3

public static Vec4 max3(Vec4 value1,
                        Vec4 value2)

min3

public static Vec4 min3(Vec4 value1,
                        Vec4 value2)

mix3

public static Vec4 mix3(double amount,
                        Vec4 value1,
                        Vec4 value2)

multiply3

public final Vec4 multiply3(double value)

multiply3

public final Vec4 multiply3(Vec4 vec4)

normalize3

public final Vec4 normalize3()

perpendicularTo3

public final Vec4 perpendicularTo3(Vec4 vec4)

perpendicularVectors

public Vec4[] perpendicularVectors()

Computes two vectors mutually perpendicular to this vector and each other.

Returns:

an array of two unit vectors mutually orthogonal to this vector.

projectOnto3

public final Vec4 projectOnto3(Vec4 vec4)

subtract3

public final Vec4 subtract3(double x,
                            double y,
                            double z)

subtract3

public final Vec4 subtract3(Vec4 vec4)

toArray2

public final double[] toArray2(double[] array,
                               int offset)

Writes this Vec4's x and y values to the specified double array. The specified offset must be 0 or greater, and the array must have have capacity equal to or greater than offset + 2. Coordinates are written to the array as follows:

array[offset] = x
array[offset + 1] = y

Parameters:

array - the double array to receive the coordinate data.

offset - the array starting index.

Returns:

the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, or if the array's capacity is less than offset + 2.

toArray3

public final double[] toArray3(double[] array,
                               int offset)

Writes this Vec4's x, y and z values to the specified double array. The specified offset must be 0 or greater, and the array must have have capacity equal to or greater than offset + 3. Coordinates are written to the array as follows:

array[offset] = x
array[offset + 1] = y
array[offset + 2] = z

Parameters:

array - the double array to receive the coordinate data.

offset - the array starting index.

Returns:

the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, or if the array's capacity is less than offset + 3.

toArray4

public final double[] toArray4(double[] array,
                               int offset)

Writes this Vec4's x, y, z and w values to the specified double array. The specified offset must be 0 or greater, and the array must have have capacity equal to or greater than offset + 4. Coordinates are written to the array as follows:

array[offset] = x
array[offset + 1] = y
array[offset + 2] = z
array[offset + 3] = w

Parameters:

array - the double array to receive the coordinate data.

offset - the array starting index.

Returns:

the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, or if the array's capacity is less than offset + 4.

toDoubleArray

public final double[] toDoubleArray(double[] array,
                                    int offset,
                                    int length)

Writes this Vec4's coordinate values to the specified double array. The specified offset must be 0 or greater, the specified length must be 1 or greater, and the array must have capacity equal to or greater than offset + length. Coordinates are written to the array as follows:

array[offset] = x
array[offset + 1] = y if length > 1, otherwise array[offset + 1] is not written to
array[offset + 2] = z if length > 2, otherwise array[offset + 2] is not written to
array[offset + 3] = w if length > 3, otherwise array[offset + 3] is not written to

Parameters:

array - the double array to receive the coordinate data.

offset - the array starting index.

length - the number of coordinates to write.

Returns:

the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, if length is less than 1, or if the array's capacity is less than offset + length.

toFloatArray

public final float[] toFloatArray(float[] array,
                                  int offset,
                                  int length)

Writes this Vec4's coordinate values to the specified float array. The specified offset must be 0 or greater, the specified length must be 1 or greater, and the array must have capacity equal to or greater than offset + length. Coordinates are written to the array as follows:

array[offset] = x
array[offset + 1] = y if length > 1, otherwise array[offset + 1] is not written to
array[offset + 2] = z if length > 2, otherwise array[offset + 2] is not written to
array[offset + 3] = w if length > 3, otherwise array[offset + 3] is not written to

Parameters:

array - the float array to receive the coordinate data.

offset - the array starting index.

length - the number of coordinates to write.

Returns:

the specified double array.

Throws:

IllegalArgumentException - if the array is null, if offset is negative, if length is less than 1, or if the array's capacity is less than offset + length.

toHomogeneousDirection3

public Vec4 toHomogeneousDirection3()

Returns a representation of this vector as an x y z direction suitable for use where four-dimensional homogeneous coordinates are required. The returned vector has x y z coordinates are equal to this vector's x y z coordinates, and has w coordinate equal to 0.0.

A three-dimensional direction in homogeneous coordinates is necessary when transforming that direction by a 4x4 transformation matrix. The returned vector is not affected by the translation component of a 4x4 transformation matrix, and therefore remains invariant under translation.

Returns:

this Vec4 converted to a direction vector in four-dimensional homogeneous coordinates.

toHomogeneousPoint3

public Vec4 toHomogeneousPoint3()

Returns a representation of this vector as an x y z point suitable for use where four-dimensional homogeneous coordinates are required. The returned vector has x y z coordinates are equal to this vector's x y z coordinates, and has w coordinate equal to 1.0.

A three-dimensional point in homogeneous coordinates is necessary when transforming that point by a 4x4 transformation matrix, or when calculating the dot product of the point and the equation of a plane. The returned vector is affected by the translation component of a 4x4 transformation matrix.

Returns:

this Vec4 converted to a point vector in four-dimensional homogeneous coordinates.

toString

public final String toString()

Overrides:

toString in class Object

transformBy3

public final Vec4 transformBy3(Matrix matrix)

transformBy3

public final Vec4 transformBy3(Quaternion quaternion)

transformBy4

public final Vec4 transformBy4(Matrix matrix)

w

public final double w()

x

public final double x()

y

public final double y()

z

public final double z()