NASA World Wind
gov.nasa.worldwind.geom

## Class Vec4

• ```public class Vec4
extends Object```
• ### Field Summary

Fields
Modifier and Type Field and Description
`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

Constructors
Constructor and Description
`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

All Methods
Modifier and Type Method and Description
`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 `Vec4`s.
`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

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

`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 `Vec4`s. 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 `Vec4`s 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 `Vec4`s
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()`