Class Vector3D

java.lang.Object
gaiasky.util.math.Vector3D
All Implemented Interfaces:
VectorDouble<Vector3D>
public class Vector3D extends Object implements VectorDouble<Vector3D>

  • Field Details

    • X

      public static final Vector3D X

    • Y

      public static final Vector3D Y

    • Z

      public static final Vector3D Z

    • Zero

      public static final Vector3D Zero

    • x

      public double x
      the x-component of this vector

    • y

      public double y
      the y-component of this vector

    • z

      public double z
      the z-component of this vector

  • Constructor Details

    • Vector3D

      public Vector3D()
      Constructs a vector at (0,0,0)

    • Vector3D

      public Vector3D(double x, double y, double z)
      Creates a vector with the given components
      Parameters:
      x - The x-component
      y - The y-component
      z - The z-component

    • Vector3D

      public Vector3D(Vector3D vec)
      Creates a vector from the given vector
      Parameters:
      vec - The vector

    • Vector3D

      public Vector3D(double[] values)
      Creates a vector from the given array. The array must have at least 3 elements.
      Parameters:
      values - The array

  • Method Details

    • getUnitX

      public static Vector3D getUnitX()

    • getUnitY

      public static Vector3D getUnitY()

    • getUnitZ

      public static Vector3D getUnitZ()

    • len

      public static double len(double x, double y, double z)
      Returns:
      The euclidean length

    • dot

      public static double dot(double x1, double y1, double z1, double x2, double y2, double z2)
      Returns:
      The dot product between the two vectors

    • crs

      public static Vector3D crs(Vector3D v, Vector3D w)
      Calculates the outer product of two given vectors v and w and returns the result as a new Vector3D.
      Parameters:
      v - left operand
      w - right operand
      Returns:
      outer product of v and w

    • cross

      public static Vector3D cross(Vector3D v, Vector3D w)

    • x

      public double x()

    • y

      public double y()

    • z

      public double z()

    • set

      public Vector3D set(double x, double y, double z)
      Sets the vector to the given components
      Parameters:
      x - The x-component
      y - The y-component
      z - The z-component
      Returns:
      this vector for chaining

    • set

      public Vector3D set(Vector3D vec)
      Description copied from interface: VectorDouble
      Sets this vector from the given vector
      Specified by:
      set in interface VectorDouble<Vector3D>
      Parameters:
      vec - The vector
      Returns:
      This vector for chaining

    • set

      public Vector3D set(Vector3Q vec)

    • set

      public Vector3D set(com.badlogic.gdx.math.Vector3 vec)

    • put

      public com.badlogic.gdx.math.Vector3 put(com.badlogic.gdx.math.Vector3 vec)

    • put

      public Vector3D put(Vector3D vec)

    • set

      public Vector3D set(double[] values)
      Sets the components from the array. The array must have at least 3 elements
      Parameters:
      values - The array
      Returns:
      this vector for chaining

    • set

      public Vector3D set(float[] values)
      Sets the components from the array. The array must have at least 3 elements
      Parameters:
      values - The array
      Returns:
      this vector for chaining

    • setFromSpherical

      public Vector3D setFromSpherical(double azimuthalAngle, double polarAngle)
      Sets the components from the given spherical coordinate
      Parameters:
      azimuthalAngle - The angle between x-axis in radians [0, 2pi]
      polarAngle - The angle between z-axis in radians [0, pi]
      Returns:
      This vector for chaining

    • setToRandomDirection

      public Vector3D setToRandomDirection()
      Description copied from interface: VectorDouble
      Sets this vector to the unit vector with a random direction
      Specified by:
      setToRandomDirection in interface VectorDouble<Vector3D>
      Returns:
      This vector for chaining

    • cpy

      public Vector3D cpy()
      Specified by:
      cpy in interface VectorDouble<Vector3D>
      Returns:
      a copy of this vector

    • add

      public Vector3D add(Vector3D vec)
      Description copied from interface: VectorDouble
      Adds the given vector to this vector
      Specified by:
      add in interface VectorDouble<Vector3D>
      Parameters:
      vec - The vector
      Returns:
      This vector for chaining

    • add

      public Vector3D add(Vector3Q vec)

    • add

      public Vector3D add(com.badlogic.gdx.math.Vector3 vec)

    • add

      public Vector3D add(double x, double y, double z)
      Adds the given vector to this component
      Parameters:
      x - The x-component of the other vector
      y - The y-component of the other vector
      z - The z-component of the other vector
      Returns:
      This vector for chaining.

    • add

      public Vector3D add(double... vals)
      Adds the given vector to this component
      Parameters:
      vals - The 3-value double vector.
      Returns:
      This vector for chaining.

    • add

      public Vector3D add(double values)
      Adds the given value to all three components of the vector.
      Parameters:
      values - The value
      Returns:
      This vector for chaining

    • sub

      public Vector3D sub(Vector3D vec)
      Description copied from interface: VectorDouble
      Subtracts the given vector from this vector.
      Specified by:
      sub in interface VectorDouble<Vector3D>
      Parameters:
      vec - The vector
      Returns:
      This vector for chaining

    • sub

      public Vector3D sub(Vector3Q vec)

    • sub

      public Vector3D sub(com.badlogic.gdx.math.Vector3 vec)

    • sub

      public Vector3D sub(double x, double y, double z)
      Subtracts the other vector from this vector.
      Parameters:
      x - The x-component of the other vector
      y - The y-component of the other vector
      z - The z-component of the other vector
      Returns:
      This vector for chaining

    • sub

      public Vector3D sub(double value)
      Subtracts the given value from all components of this vector
      Parameters:
      value - The value
      Returns:
      This vector for chaining

    • scl

      public Vector3D scl(double scalar)
      Description copied from interface: VectorDouble
      Scales this vector by a scalar
      Specified by:
      scl in interface VectorDouble<Vector3D>
      Parameters:
      scalar - The scalar
      Returns:
      This vector for chaining

    • scale

      public static Vector3D scale(double scalar, Vector3D in)

    • scl

      public Vector3D scl(Vector3D vec)
      Description copied from interface: VectorDouble
      Scales this vector by another vector
      Specified by:
      scl in interface VectorDouble<Vector3D>
      Returns:
      This vector for chaining

    • scl

      public Vector3D scl(double vx, double vy, double vz)
      Scales this vector by the given values
      Parameters:
      vx - X value
      vy - Y value
      vz - Z value
      Returns:
      This vector for chaining

    • mulAdd

      public Vector3D mulAdd(Vector3D vec, double scalar)
      Description copied from interface: VectorDouble
      First scale a supplied vector, then add it to this vector.
      Specified by:
      mulAdd in interface VectorDouble<Vector3D>
      Parameters:
      vec - addition vector.
      scalar - for scaling the addition vector.

    • mulAdd

      public Vector3D mulAdd(Vector3D vec, Vector3D mulVec)
      Description copied from interface: VectorDouble
      First scale a supplied vector, then add it to this vector.
      Specified by:
      mulAdd in interface VectorDouble<Vector3D>
      Parameters:
      vec - addition vector.
      mulVec - vector by whose values the addition vector will be scaled.

    • mul

      public Vector3D mul(Vector3D vec)

    • div

      public Vector3D div(Vector3D vec)

    • len

      public double len()
      Specified by:
      len in interface VectorDouble<Vector3D>
      Returns:
      The euclidean length

    • len2

      public double len2()
      Description copied from interface: VectorDouble
      This method is faster than VectorDouble.len() because it avoids calculating a square root. It is useful for comparisons, but not for getting exact lengths, as the return value is the square of the actual length.
      Specified by:
      len2 in interface VectorDouble<Vector3D>
      Returns:
      The squared euclidean length

    • idt

      public boolean idt(Vector3D vec)
      Parameters:
      vec - The other vector
      Returns:
      Whether this and the other vector are equal

    • dst

      public double dst(Vector3D vec)
      Specified by:
      dst in interface VectorDouble<Vector3D>
      Parameters:
      vec - The other vector
      Returns:
      the distance between this and the other vector

    • dst

      public double dst(Vector3Q vec)

    • dst

      public double dst(double x, double y, double z)
      Returns:
      the distance between this point and the given point

    • dst2

      public double dst2(Vector3Q vec)

    • dst2

      public double dst2(Vector3D vec)
      Description copied from interface: VectorDouble
      This method is faster than VectorDouble.dst(VectorDouble) because it avoids calculating a square root. It is useful for comparisons, but not for getting accurate distances, as the return value is the square of the actual distance.
      Specified by:
      dst2 in interface VectorDouble<Vector3D>
      Parameters:
      vec - The other vector
      Returns:
      the squared distance between this and the other vector

    • dst2

      public double dst2(double x, double y, double z)
      Returns the squared distance between this point and the given point
      Parameters:
      x - The x-component of the other point
      y - The y-component of the other point
      z - The z-component of the other point
      Returns:
      The squared distance

    • nor

      public Vector3D nor()
      Description copied from interface: VectorDouble
      Normalizes this vector. Does nothing if it is zero.
      Specified by:
      nor in interface VectorDouble<Vector3D>
      Returns:
      This vector for chaining

    • dot

      public double dot(Vector3D vector)
      Specified by:
      dot in interface VectorDouble<Vector3D>
      Parameters:
      vector - The other vector
      Returns:
      The dot product between this and the other vector

    • dot

      public double dot(Vector3Q vector)

    • dot

      public double dot(double x, double y, double z)
      Returns the dot product between this and the given vector.
      Parameters:
      x - The x-component of the other vector
      y - The y-component of the other vector
      z - The z-component of the other vector
      Returns:
      The dot product

    • crs

      public Vector3D crs(Vector3D vec)
      Sets this vector to the cross product between it and the other vector.
      Parameters:
      vec - The other vector
      Returns:
      This vector for chaining

    • crs

      public Vector3D crs(double x, double y, double z)
      Sets this vector to the cross product between it and the other vector.
      Parameters:
      x - The x-component of the other vector
      y - The y-component of the other vector
      z - The z-component of the other vector
      Returns:
      This vector for chaining

    • mul4x3

      public Vector3D mul4x3(double[] matrix)
      Left-multiplies the vector by the given 4x3 column major matrix. The matrix should be composed by a 3x3 matrix representing rotation and scale plus a 1x3 matrix representing the translation.
      Parameters:
      matrix - The matrix
      Returns:
      This vector for chaining

    • mul

      public Vector3D mul(Matrix4D matrix)
      Left-multiplies the vector by the given matrix, assuming the fourth (w) component of the vector is 1.
      Parameters:
      matrix - The matrix
      Returns:
      This vector for chaining

    • mulLeft

      public Vector3D mulLeft(com.badlogic.gdx.math.Matrix3 matrix)

    • mulRight

      public Vector3D mulRight(com.badlogic.gdx.math.Matrix3 matrix)

    • traMul

      public Vector3D traMul(Matrix4D matrix)
      Multiplies the vector by the transpose of the given matrix, assuming the fourth (w) component of the vector is 1.
      Parameters:
      matrix - The matrix
      Returns:
      This vector for chaining

    • mul

      public Vector3D mul(Matrix3D matrix)
      Left-multiplies the vector by the given matrix.
      Parameters:
      matrix - The matrix public Vector3D mul (Matrix3D matrix) {
      Returns:
      This vector for chaining

    • traMul

      public Vector3D traMul(Matrix3D matrix)
      Multiplies the vector by the transpose of the given matrix.
      Parameters:
      matrix - The matrix
      Returns:
      This vector for chaining

    • mul

      public Vector3D mul(QuaternionDouble quat)
      Multiplies the vector by the given Quaternion.
      Returns:
      This vector for chaining

    • prj

      public Vector3D prj(Matrix4D matrix)
      Multiplies this vector by the given matrix dividing by w, assuming the fourth (w) component of the vector is 1. This is mostly used to project/unproject vectors via a perspective projection matrix.
      Parameters:
      matrix - The matrix.
      Returns:
      This vector for chaining

    • rot

      public Vector3D rot(Matrix4D matrix)
      Multiplies this vector by the first three columns of the matrix, essentially only applying rotation and scaling.
      Parameters:
      matrix - The matrix
      Returns:
      This vector for chaining

    • unrotate

      public Vector3D unrotate(Matrix4D matrix)
      Multiplies this vector by the transpose of the first three columns of the matrix. Note: only works for translation and rotation, does not work for scaling. For those, use rot(Matrix4D) with Matrix4D.inv().
      Parameters:
      matrix - The transformation matrix
      Returns:
      The vector for chaining

    • untransform

      public Vector3D untransform(Matrix4D matrix)
      Translates this vector in the direction opposite to the translation of the matrix and the multiplies this vector by the transpose of the first three columns of the matrix. Note: only works for translation and rotation, does not work for scaling. For those, use mul(Matrix4D) with Matrix4D.inv().
      Parameters:
      matrix - The transformation matrix
      Returns:
      The vector for chaining

    • rotate

      public Vector3D rotate(double degrees, double axisX, double axisY, double axisZ)
      Rotates this vector by the given angle in degrees around the given axis.
      Parameters:
      degrees - the angle in degrees
      axisX - the x-component of the axis
      axisY - the y-component of the axis
      axisZ - the z-component of the axis
      Returns:
      This vector for chaining

    • rotateRad

      public Vector3D rotateRad(double radians, double axisX, double axisY, double axisZ)
      Rotates this vector by the given angle in radians around the given axis.
      Parameters:
      radians - the angle in radians
      axisX - the x-component of the axis
      axisY - the y-component of the axis
      axisZ - the z-component of the axis
      Returns:
      This vector for chaining

    • rotate

      public Vector3D rotate(Vector3D axis, double degrees)
      Rotates this vector by the given angle in degrees around the given axis.
      Parameters:
      axis - the axis
      degrees - the angle in degrees
      Returns:
      This vector for chaining

    • rotateRad

      public Vector3D rotateRad(Vector3D axis, double radians)
      Rotates this vector by the given angle in radians around the given axis.
      Parameters:
      axis - the axis
      radians - the angle in radians
      Returns:
      This vector for chaining

    • getMatrix

      public com.badlogic.gdx.math.Matrix4 getMatrix(com.badlogic.gdx.math.Matrix4 aux)
      Sets the matrix aux to a translation matrix using this vector
      Parameters:
      aux - The matrix.
      Returns:
      The matrix aux.

    • getMatrix

      public Matrix4D getMatrix(Matrix4D aux)
      Sets the given matrix to a translation matrix using this vector
      Parameters:
      aux - The out matrix
      Returns:
      The matrix with the transform

    • isUnit

      public boolean isUnit()
      Specified by:
      isUnit in interface VectorDouble<Vector3D>
      Returns:
      Whether this vector is a unit length vector

    • isUnit

      public boolean isUnit(double margin)
      Specified by:
      isUnit in interface VectorDouble<Vector3D>
      Returns:
      Whether this vector is a unit length vector within the given margin.

    • isZero

      public boolean isZero()
      Specified by:
      isZero in interface VectorDouble<Vector3D>
      Returns:
      Whether this vector is a zero vector

    • isZero

      public boolean isZero(double margin)
      Specified by:
      isZero in interface VectorDouble<Vector3D>
      Returns:
      Whether the length of this vector is smaller than the given margin

    • isOnLine

      public boolean isOnLine(Vector3D vec, double epsilon)
      Specified by:
      isOnLine in interface VectorDouble<Vector3D>
      Returns:
      true if this vector is in line with the other vector (either in the same or the opposite direction)

    • isOnLine

      public boolean isOnLine(Vector3D vec)
      Specified by:
      isOnLine in interface VectorDouble<Vector3D>
      Returns:
      true if this vector is in line with the other vector (either in the same or the opposite direction)

    • isCollinear

      public boolean isCollinear(Vector3D vec, double epsilon)
      Specified by:
      isCollinear in interface VectorDouble<Vector3D>
      Returns:
      true if this vector is collinear with the other vector (VectorDouble.isOnLine(VectorDouble, double) and VectorDouble.hasSameDirection(VectorDouble)).

    • isCollinear

      public boolean isCollinear(Vector3D vec)
      Specified by:
      isCollinear in interface VectorDouble<Vector3D>
      Returns:
      true if this vector is collinear with the other vector (VectorDouble.isOnLine(VectorDouble) and VectorDouble.hasSameDirection(VectorDouble)).

    • isCollinearOpposite

      public boolean isCollinearOpposite(Vector3D vec, double epsilon)
      Specified by:
      isCollinearOpposite in interface VectorDouble<Vector3D>
      Returns:
      true if this vector is opposite collinear with the other vector (VectorDouble.isOnLine(VectorDouble, double) and VectorDouble.hasOppositeDirection(VectorDouble)).

    • isCollinearOpposite

      public boolean isCollinearOpposite(Vector3D vec)
      Specified by:
      isCollinearOpposite in interface VectorDouble<Vector3D>
      Returns:
      true if this vector is opposite collinear with the other vector (VectorDouble.isOnLine(VectorDouble) and VectorDouble.hasOppositeDirection(VectorDouble)).

    • isPerpendicular

      public boolean isPerpendicular(Vector3D vec)
      Specified by:
      isPerpendicular in interface VectorDouble<Vector3D>
      Returns:
      Whether this vector is perpendicular with the other vector. True if the dot product is 0.

    • isPerpendicular

      public boolean isPerpendicular(Vector3D vec, double epsilon)
      Specified by:
      isPerpendicular in interface VectorDouble<Vector3D>
      Parameters:
      epsilon - a positive small number close to zero
      Returns:
      Whether this vector is perpendicular with the other vector. True if the dot product is 0.

    • hasSameDirection

      public boolean hasSameDirection(Vector3D vec)
      Specified by:
      hasSameDirection in interface VectorDouble<Vector3D>
      Returns:
      Whether this vector has similar direction compared to the other vector. True if the normalized dot product is >0.

    • hasOppositeDirection

      public boolean hasOppositeDirection(Vector3D vec)
      Specified by:
      hasOppositeDirection in interface VectorDouble<Vector3D>
      Returns:
      Whether this vector has opposite direction compared to the other vector. True if the normalized dot product is <0.

    • lerp

      public Vector3D lerp(Vector3D vec, double alpha)
      Description copied from interface: VectorDouble
      Linearly interpolates between this vector and the target vector by alpha which is in the range [0,1]. The result is stored in this vector.
      Specified by:
      lerp in interface VectorDouble<Vector3D>
      Parameters:
      vec - The target vector
      alpha - The interpolation coefficient
      Returns:
      This vector for chaining.

    • interpolate

      public Vector3D interpolate(Vector3D vec, double alpha, InterpolationDouble interpolator)
      Description copied from interface: VectorDouble
      Interpolates between this vector and the given target vector by alpha (within range [0,1]) using the given Interpolation method. the result is stored in this vector.
      Specified by:
      interpolate in interface VectorDouble<Vector3D>
      Parameters:
      vec - The target vector
      alpha - The interpolation coefficient
      interpolator - An Interpolation object describing the used interpolation method
      Returns:
      This vector for chaining.

    • slerp

      public Vector3D slerp(Vector3D vec, double alpha)
      Spherically interpolates between this vector and the target vector by alpha which is in the range [0,1]. The result is stored in this vector.
      Parameters:
      vec - The target vector
      alpha - The interpolation coefficient
      Returns:
      This vector for chaining.

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • limit

      public Vector3D limit(double limit)
      Description copied from interface: VectorDouble
      Limits the length of this vector, based on the desired maximum length.
      Specified by:
      limit in interface VectorDouble<Vector3D>
      Parameters:
      limit - desired maximum length for this vector
      Returns:
      this vector for chaining

    • limit2

      public Vector3D limit2(double limit2)
      Description copied from interface: VectorDouble

      Limits the length of this vector, based on the desired maximum length squared.

      This method is slightly faster than limit().
      Specified by:
      limit2 in interface VectorDouble<Vector3D>
      Parameters:
      limit2 - squared desired maximum length for this vector
      Returns:
      this vector for chaining
      See Also:

    • setLength

      public Vector3D setLength(double len)
      Description copied from interface: VectorDouble
      Sets the length of this vector. Does nothing is this vector is zero.
      Specified by:
      setLength in interface VectorDouble<Vector3D>
      Parameters:
      len - desired length for this vector
      Returns:
      this vector for chaining

    • setLength2

      public Vector3D setLength2(double len2)
      Description copied from interface: VectorDouble

      Sets the length of this vector, based on the square of the desired length. Does nothing is this vector is zero.

      This method is slightly faster than setLength().
      Specified by:
      setLength2 in interface VectorDouble<Vector3D>
      Parameters:
      len2 - desired square of the length for this vector.
      Returns:
      this vector for chaining.
      See Also:

    • clamp

      public Vector3D clamp(double min, double max)
      Description copied from interface: VectorDouble
      Clamps this vector's length to given min and max values
      Specified by:
      clamp in interface VectorDouble<Vector3D>
      Parameters:
      min - Min length
      max - Max length
      Returns:
      This vector for chaining

    • values

      public double[] values()

    • valuesF

      public float[] valuesF()

    • valuesF

      public float[] valuesF(float[] vec)

    • scaleAdd

      public Vector3D scaleAdd(double s, Vector3D vec)
      Scales a given vector with a scalar and add the result to this one, i.e. this = this + s*v.
      Parameters:
      s - scalar scaling factor
      vec - vector to scale
      Returns:
      vector modified in place

    • toVector3

      public com.badlogic.gdx.math.Vector3 toVector3()
      Returns a vector3 representation of this vector by casting the doubles to floats. This creates a new object
      Returns:
      The vector3 representation of this vector3d

    • setVector3

      public com.badlogic.gdx.math.Vector3 setVector3(com.badlogic.gdx.math.Vector3 v)
      Returns set v to this vector by casting doubles to floats.
      Returns:
      The float vector v.

    • rotateVectorByQuaternion

      public Vector3D rotateVectorByQuaternion(QuaternionDouble q)
      Rotates this vector by a quaternion, using "vector rotation" according to (60) in LL-072. Both the original and the returned vectors are expressed in the same reference frame as the quaternion.
      Parameters:
      q - Quaternion defining the vector rotation.
      Returns:
      the rotated vector.

    • angle

      public double angle(Vector3D v)
      Gets the angle in degrees between the two vectors

    • angle

      public double angle(Vector3Q v)
      Gets the angle in degrees between the two vectors

    • anglePrecise

      public double anglePrecise(Vector3D v)
      Gets the angle in degrees between the two vectors

    • hasNaN

      public boolean hasNaN()

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object

    • epsilonEquals

      public boolean epsilonEquals(Vector3D vec, double epsilon)
      Description copied from interface: VectorDouble
      Compares this vector with the other vector, using the supplied epsilon for fuzzy equality testing.
      Specified by:
      epsilonEquals in interface VectorDouble<Vector3D>
      Parameters:
      vec - The other vector.
      epsilon - The maximum deviation.
      Returns:
      whether the vectors have fuzzy equality.

    • epsilonEquals

      public boolean epsilonEquals(float x, float y, float z, float epsilon)
      Compares this vector with the other vector, using the supplied epsilon for fuzzy equality testing.
      Returns:
      whether the vectors are the same.

    • epsilonEquals

      public boolean epsilonEquals(Vector3D vec)
      Compares this vector with the other vector using MathUtils.FLOAT_ROUNDING_ERROR for fuzzy equality testing
      Parameters:
      vec - other vector to compare
      Returns:
      true if vector are equal, otherwise false

    • epsilonEquals

      public boolean epsilonEquals(float x, float y, float z)
      Compares this vector with the other vector using MathUtils.FLOAT_ROUNDING_ERROR for fuzzy equality testing
      Parameters:
      x - x component of the other vector to compare
      y - y component of the other vector to compare
      z - z component of the other vector to compare
      Returns:
      true if vector are equal, otherwise false

    • setZero

      public Vector3D setZero()
      Description copied from interface: VectorDouble
      Sets the components of this vector to 0.
      Specified by:
      setZero in interface VectorDouble<Vector3D>
      Returns:
      This vector for chaining.

    • getLatitude

      public double getLatitude()
      Returns the latitude of this vector in the reference frame with the Z axis pointing toward the North pole and the X axis pointing towards zero longitude.
      Returns:
      latitude [rad] of the vector in the range [-Pi/2, +Pi]

    • getLongitude

      public double getLongitude()
      Returns the longitude of this vector in the reference frame with the Z axis pointing towards the North pole and the X axis pointing towards zero longitude.
      Returns:
      longitude [rad] of the vector in the range [0, 2Pi)

    • toSphericalCoordinates

      public Vector2D toSphericalCoordinates()
      Converts the current direction cosines to spherical coordinates.
      Returns:
      Longitude [0, 2*Pi] and latitude [-Pi/2, Pi/2] corresponding to the current direction cosine as a Vector2D