Cartesian2 (CesiumJS GWT Wrapper 1.59.4 API)

java.lang.Object
- org.cesiumjs.cs.core.Cartesian2

All Implemented Interfaces:: Packable

@JsType(isNative=true,
        namespace="Cesium",
        name="Cartesian2")
public class Cartesian2
extends Object
implements Packable

Author:: Serge Silaev aka iSergio
See Also:: Cartesian3, Cartesian4

Field Summary

Fields
Modifier and Type Field and Description

static int packedLength
The number of elements used to pack the object into an array.

double x
The X component.

double y
The Y component.

Fields
Modifier and Type	Field and Description
`static int`	`packedLength` The number of elements used to pack the object into an array.
`double`	`x` The X component.
`double`	`y` The Y component.

Constructor Summary

Constructors
Constructor and Description

Cartesian2()
A 2D Cartesian point.

Cartesian2(double x, double y)
A 2D Cartesian point.

Constructors
Constructor and Description
`Cartesian2()` A 2D Cartesian point.
`Cartesian2(double x, double y)` A 2D Cartesian point.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static Cartesian2`	`abs(Cartesian2 cartesian, Cartesian2 result)` Computes the absolute value of the provided Cartesian.
`static Cartesian2`	`add(Cartesian2 left, Cartesian2 right, Cartesian2 result)` Computes the componentwise sum of two Cartesians.
`static double`	`angleBetween(Cartesian2 left, Cartesian2 right)` Returns the angle, in radians, between the provided Cartesians.
`Cartesian2`	`clone()` Duplicates this Cartesian2 instance.
`Cartesian2`	`clone(Cartesian2 result)` Duplicates this Cartesian2 instance.
`static Cartesian2`	`clone(Cartesian2 cartesian, Cartesian2 result)` Duplicates a Cartesian2 instance.
`static double`	`distance(Cartesian2 left, Cartesian2 right)` Computes the distance between two points.
`static double`	`distanceSquared(Cartesian2 left, Cartesian2 right)` Computes the squared distance between two points.
`static Cartesian2`	`divideByScalar(Cartesian2 cartesian, double scalar, Cartesian2 result)` Divides the provided Cartesian componentwise by the provided scalar.
`static Cartesian2`	`divideComponents(Cartesian2 left, Cartesian2 right, Cartesian2 result)` Computes the componentwise quotient of two Cartesians.
`static double`	`dot(Cartesian2 left, Cartesian2 right)` Computes the dot (scalar) product of two Cartesians.
`Cartesian2`	`equals(Cartesian2 right)` Compares this Cartesian against the provided Cartesian componentwise and returns true if they are equal, false otherwise.
`static boolean`	`equals(Cartesian2 left, Cartesian2 right)` Compares the provided Cartesians componentwise and returns true if they are equal, false otherwise.
`static boolean`	`equalsEpsilon(Cartesian2 left, Cartesian2 right, double relativeEpsilon, double absoluteEpsilon)` Compares the provided Cartesians componentwise and returns true if they pass an absolute or relative tolerance test, false otherwise.
`boolean`	`equalsEpsilon(Cartesian2 right, double relativeEpsilon, double absoluteEpsilon)` Compares this Cartesian against the provided Cartesian componentwise and returns true if they pass an absolute or relative tolerance test, false otherwise.
`static Cartesian2`	`fromArray(double[] array, Cartesian2 result)` Creates a Cartesian2 from two consecutive elements in an array.
`static Cartesian2`	`fromArray(double[] array, int startingIndex, Cartesian2 result)` Creates a Cartesian2 from two consecutive elements in an array.
`static Cartesian2`	`fromArray(com.google.gwt.core.client.JsArrayNumber array, Cartesian2 result)` Creates a Cartesian2 from two consecutive elements in an array.
`static Cartesian2`	`fromArray(com.google.gwt.core.client.JsArrayNumber array, int startingIndex, Cartesian2 result)` Creates a Cartesian2 from two consecutive elements in an array.
`static Cartesian2`	`fromCartesian3(Cartesian3 cartesian, Cartesian2 result)` Creates a Cartesian2 instance from an existing Cartesian3.
`static Cartesian2`	`fromCartesian4(Cartesian4 cartesian, Cartesian2 result)` Creates a Cartesian2 instance from an existing Cartesian4.
`static Cartesian2`	`fromElements(double x, double y, Cartesian2 result)` Creates a Cartesian2 instance from x and y coordinates.
`static Cartesian2`	`lerp(Cartesian2 start, Cartesian2 end, double t, Cartesian2 result)` Computes the linear interpolation or extrapolation at t using the provided cartesians.
`static double`	`magnitude(Cartesian2 cartesian)` Computes the Cartesian's magnitude (length).
`static double`	`magnitudeSquared(Cartesian2 cartesian)` Computes the provided Cartesian's squared magnitude.
`static Cartesian2`	`maximumByComponent(Cartesian2 first, Cartesian2 second, Cartesian2 result)` Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
`static double`	`maximumComponent(Cartesian2 cartesian)` Computes the value of the maximum component for the supplied Cartesian.
`static Cartesian2`	`minimumByComponent(Cartesian2 first, Cartesian2 second, Cartesian2 result)` Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
`static double`	`minimumComponent(Cartesian2 cartesian)` Computes the value of the minimum component for the supplied Cartesian.
`static Cartesian2`	`mostOrthogonalAxis(Cartesian2 cartesian, Cartesian2 result)` Returns the axis that is most orthogonal to the provided Cartesian.
`static Cartesian2`	`multiplyByScalar(Cartesian2 cartesian, double scalar, Cartesian2 result)` Multiplies the provided Cartesian componentwise by the provided scalar.
`static Cartesian2`	`multiplyComponents(Cartesian2 left, Cartesian2 right, Cartesian2 result)` Computes the componentwise product of two Cartesians.
`static Cartesian2`	`negate(Cartesian2 cartesian, Cartesian2 result)` Negates the provided Cartesian.
`static Cartesian2`	`normalize(Cartesian2 cartesian, Cartesian2 result)` Computes the normalized form of the supplied Cartesian.
`static com.google.gwt.core.client.JsArrayNumber`	`pack(Cartesian2 value, com.google.gwt.core.client.JsArrayNumber array, int startingIndex)` Stores the provided instance into the provided array.
`static com.google.gwt.core.client.JsArrayNumber`	`packArray(Cartesian2[] array, com.google.gwt.core.client.JsArrayNumber result)` Flattens an array of Cartesian2s into and array of components.
`static Cartesian2`	`subtract(Cartesian2 left, Cartesian2 right, Cartesian2 result)` Computes the componentwise difference of two Cartesians.
`String`	`toString()` Creates a string representing this Cartesian in the format '(x, y)'.
`static Cartesian2`	`UNIT_X()` An immutable Cartesian2 instance initialized to (1.0, 0.0).
`static Cartesian2`	`UNIT_Y()` An immutable Cartesian2 instance initialized to (0.0, 1.0).
`static Cartesian2`	`unpack(com.google.gwt.core.client.JsArrayNumber array)` Retrieves an instance from a packed array.
`static Cartesian2`	`unpack(com.google.gwt.core.client.JsArrayNumber array, int startingIndex, Cartesian2 result)` Retrieves an instance from a packed array.
`static Cartesian2[]`	`unpackArray(com.google.gwt.core.client.JsArrayNumber array, Cartesian2[] result)` Unpacks an array of cartesian components into and array of Cartesian2s.
`static Cartesian2`	`ZERO()` An immutable Cartesian2 instance initialized to (0.0, 0.0).

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - x
```
@JsProperty
public double x
```
    The X component. Default Value: 0.0
  - y
```
@JsProperty
public double y
```
    The Y component. Default Value: 0.0
  - packedLength
```
@JsProperty
public static int packedLength
```
    The number of elements used to pack the object into an array.
- Constructor Detail
  - Cartesian2
```
@JsConstructor
public Cartesian2()
```
    A 2D Cartesian point.
    
    See Also:
    
    Cartesian3, Cartesian4
  - Cartesian2
```
@JsConstructor
public Cartesian2(double x,
                                 double y)
```
    A 2D Cartesian point.
    
    Parameters:
    
    x - The X component. Default Value: 0.0
    
    y - The Y component. Default Value: 0.0
    
    See Also:
    
    Cartesian3, Cartesian4
- Method Detail
  - UNIT_X
```
@JsProperty(name="UNIT_X")
public static Cartesian2 UNIT_X()
```
    An immutable Cartesian2 instance initialized to (1.0, 0.0).
  - UNIT_Y
```
@JsProperty(name="UNIT_Y")
public static Cartesian2 UNIT_Y()
```
    An immutable Cartesian2 instance initialized to (0.0, 1.0).
  - ZERO
```
@JsProperty(name="ZERO")
public static Cartesian2 ZERO()
```
    An immutable Cartesian2 instance initialized to (0.0, 0.0).
  - clone
```
@JsMethod
public Cartesian2 clone(Cartesian2 result)
```
    Duplicates this Cartesian2 instance.
    
    Parameters:
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - clone
```
@JsMethod
public Cartesian2 clone()
```
    Duplicates this Cartesian2 instance.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - equals
```
@JsMethod
public Cartesian2 equals(Cartesian2 right)
```
    Compares this Cartesian against the provided Cartesian componentwise and returns true if they are equal, false otherwise.
    
    Parameters:
    
    right - The right hand side Cartesian. Optional.
    
    Returns:
    
    true if they are equal, false otherwise.
  - equalsEpsilon
```
@JsMethod
public boolean equalsEpsilon(Cartesian2 right,
                                       double relativeEpsilon,
                                       double absoluteEpsilon)
```
    Compares this Cartesian against the provided Cartesian componentwise and returns true if they pass an absolute or relative tolerance test, false otherwise.
    
    Parameters:
    
    right - The right hand side Cartesian. Optional.
    
    relativeEpsilon - The relative epsilon tolerance to use for equality testing.
    
    absoluteEpsilon - The absolute epsilon tolerance to use for equality testing. Optional.
    
    Returns:
    
    true if they are within the provided epsilon, false otherwise.
  - toString
```
@JsMethod
public String toString()
```
    Creates a string representing this Cartesian in the format '(x, y)'.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    A string representing the provided Cartesian in the format '(x, y)'.
  - abs
```
@JsMethod
public static Cartesian2 abs(Cartesian2 cartesian,
                                       Cartesian2 result)
```
    Computes the absolute value of the provided Cartesian.
    
    Parameters:
    
    cartesian - The Cartesian whose absolute value is to be computed.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - add
```
@JsMethod
public static Cartesian2 add(Cartesian2 left,
                                       Cartesian2 right,
                                       Cartesian2 result)
```
    Computes the componentwise sum of two Cartesians.
    
    Parameters:
    
    left - The first Cartesian.
    
    right - The second Cartesian.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - angleBetween
```
@JsMethod
public static double angleBetween(Cartesian2 left,
                                            Cartesian2 right)
```
    Returns the angle, in radians, between the provided Cartesians.
    
    Parameters:
    
    left - The first Cartesian.
    
    right - The second Cartesian.
    
    Returns:
    
    The angle between the Cartesians.
  - clone
```
@JsMethod
public static Cartesian2 clone(Cartesian2 cartesian,
                                         Cartesian2 result)
```
    Duplicates a Cartesian2 instance.
    
    Parameters:
    
    cartesian - The Cartesian to duplicate.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided. (Returns undefined if cartesian is undefined)
  - distance
```
@JsMethod
public static double distance(Cartesian2 left,
                                        Cartesian2 right)
```
    Computes the distance between two points.
```
     Example:
     
     // Returns 1.0
     double d = Cartesian2.distance(new Cartesian2(1.0, 0.0), new Cartesian2(2.0, 0.0));
     
 
```
    Parameters:
    
    left - The first point to compute the distance from.
    
    right - The second point to compute the distance to.
    
    Returns:
    
    The distance between two points.
  - distanceSquared
```
@JsMethod
public static double distanceSquared(Cartesian2 left,
                                               Cartesian2 right)
```
    Computes the squared distance between two points. Comparing squared distances using this function is more efficient than comparing distances using Cartesian2#distance.
```
     Example:
     
     // Returns 4.0, not 2.0
     double d = Cartesian2.distanceSquared(new Cartesian2(1.0, 0.0), new Cartesian2(3.0, 0.0));
     
 
```
    Parameters:
    
    left - The first point to compute the distance from.
    
    right - The second point to compute the distance to.
    
    Returns:
    
    The distance between two points.
  - divideByScalar
```
@JsMethod
public static Cartesian2 divideByScalar(Cartesian2 cartesian,
                                                  double scalar,
                                                  Cartesian2 result)
```
    Divides the provided Cartesian componentwise by the provided scalar.
    
    Parameters:
    
    cartesian - The Cartesian to be divided.
    
    scalar - The scalar to divide by.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - divideComponents
```
@JsMethod
public static Cartesian2 divideComponents(Cartesian2 left,
                                                    Cartesian2 right,
                                                    Cartesian2 result)
```
    Computes the componentwise quotient of two Cartesians.
    
    Parameters:
    
    left - The first Cartesian.
    
    right - The second Cartesian.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - dot
```
@JsMethod
public static double dot(Cartesian2 left,
                                   Cartesian2 right)
```
    Computes the dot (scalar) product of two Cartesians.
    
    Parameters:
    
    left - The first Cartesian.
    
    right - The second Cartesian.
    
    Returns:
    
    The dot product.
  - equals
```
@JsMethod
public static boolean equals(Cartesian2 left,
                                       Cartesian2 right)
```
    Compares the provided Cartesians componentwise and returns true if they are equal, false otherwise.
    
    Parameters:
    
    left - The first Cartesian. Optional.
    
    right - The second Cartesian. Optional.
    
    Returns:
    
    true if left and right are equal, false otherwise.
  - equalsEpsilon
```
@JsMethod
public static boolean equalsEpsilon(Cartesian2 left,
                                              Cartesian2 right,
                                              double relativeEpsilon,
                                              double absoluteEpsilon)
```
    Compares the provided Cartesians componentwise and returns true if they pass an absolute or relative tolerance test, false otherwise.
    
    Parameters:
    
    left - The first Cartesian. Optional.
    
    right - The second Cartesian. Optional.
    
    relativeEpsilon - The relative epsilon tolerance to use for equality testing.
    
    absoluteEpsilon - The absolute epsilon tolerance to use for equality testing. Optional.
    
    Returns:
    
    true if left and right are within the provided epsilon, false otherwise.
  - fromArray
```
@JsMethod
public static Cartesian2 fromArray(com.google.gwt.core.client.JsArrayNumber array,
                                             Cartesian2 result)
```
    Creates a Cartesian2 from two consecutive elements in an array.
```
     Example:
     
     JsArrayNumber jsArrayNumber = JsArray.createArray().cast();
     jsArrayNumber.push(1);
     jsArrayNumber.push(2);
     Cartesian2 c = Cartesian2.fromArray(jsArrayNumber, 0, null);
     
 
```
    Parameters:
    
    array - The array whose two consecutive elements correspond to the x and y components, respectively.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - fromArray
```
@JsMethod
public static Cartesian2 fromArray(double[] array,
                                             Cartesian2 result)
```
    Creates a Cartesian2 from two consecutive elements in an array.
```
     Example:
     
     double[] array = {1, 2};
     Cartesian2 c = Cartesian2.fromArray(array, 0, null);
     
 
```
    Parameters:
    
    array - The array whose two consecutive elements correspond to the x and y components, respectively.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - fromArray
```
@JsMethod
public static Cartesian2 fromArray(com.google.gwt.core.client.JsArrayNumber array,
                                             int startingIndex,
                                             Cartesian2 result)
```
    Creates a Cartesian2 from two consecutive elements in an array.
```
     Example:
     
     JsArrayNumber jsArrayNumber = JsArray.createArray().cast();
     jsArrayNumber.push(1);
     jsArrayNumber.push(2);
     jsArrayNumber.push(3);
     jsArrayNumber.push(4);
     Cartesian2 c = Cartesian2.fromArray(jsArrayNumber, 2, null);
     
 
```
    Parameters:
    
    array - The array whose two consecutive elements correspond to the x and y components, respectively.
    
    startingIndex - The offset into the array of the first element, which corresponds to the x component. Optional.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - fromArray
```
@JsMethod
public static Cartesian2 fromArray(double[] array,
                                             int startingIndex,
                                             Cartesian2 result)
```
    Creates a Cartesian2 from two consecutive elements in an array.
```
     Example:
     
     double[] array = {1, 2, 3, 4};
     Cartesian2 c = Cartesian2.fromArray(array, 2, null);
     
 
```
    Parameters:
    
    array - The array whose two consecutive elements correspond to the x and y components, respectively.
    
    startingIndex - The offset into the array of the first element, which corresponds to the x component. Optional.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - fromCartesian3
```
@JsMethod
public static Cartesian2 fromCartesian3(Cartesian3 cartesian,
                                                  Cartesian2 result)
```
    Creates a Cartesian2 instance from an existing Cartesian3. This simply takes the x and y properties of the Cartesian3 and drops z.
    
    Parameters:
    
    cartesian - The Cartesian3 instance to create a Cartesian2 instance from.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - fromCartesian4
```
@JsMethod
public static Cartesian2 fromCartesian4(Cartesian4 cartesian,
                                                  Cartesian2 result)
```
    Creates a Cartesian2 instance from an existing Cartesian4. This simply takes the x and y properties of the Cartesian4 and drops z and w.
    
    Parameters:
    
    cartesian - The Cartesian4 instance to create a Cartesian2 instance from.
    
    result - The object onto which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - fromElements
```
@JsMethod
public static Cartesian2 fromElements(double x,
                                                double y,
                                                Cartesian2 result)
```
    Creates a Cartesian2 instance from x and y coordinates.
    
    Parameters:
    
    x - The x coordinate.
    
    y - The y coordinate.
    
    result - Cartesian2 optional The object onto which to store the result.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - lerp
```
@JsMethod
public static Cartesian2 lerp(Cartesian2 start,
                                        Cartesian2 end,
                                        double t,
                                        Cartesian2 result)
```
    Computes the linear interpolation or extrapolation at t using the provided cartesians.
    
    Parameters:
    
    start - The value corresponding to t at 0.0.
    
    end - The value corresponding to t at 1.0.
    
    t - The point along t at which to interpolate.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - magnitude
```
@JsMethod
public static double magnitude(Cartesian2 cartesian)
```
    Computes the Cartesian's magnitude (length).
    
    Parameters:
    
    cartesian - The Cartesian instance whose magnitude is to be computed.
    
    Returns:
    
    The magnitude.
  - magnitudeSquared
```
@JsMethod
public static double magnitudeSquared(Cartesian2 cartesian)
```
    Computes the provided Cartesian's squared magnitude.
    
    Parameters:
    
    cartesian - The Cartesian instance whose squared magnitude is to be computed.
    
    Returns:
    
    The squared magnitude.
  - maximumByComponent
```
@JsMethod
public static Cartesian2 maximumByComponent(Cartesian2 first,
                                                      Cartesian2 second,
                                                      Cartesian2 result)
```
    Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
    
    Parameters:
    
    first - A cartesian to compare.
    
    second - A cartesian to compare.
    
    result - The object into which to store the result.
    
    Returns:
    
    A cartesian with the maximum components.
  - maximumComponent
```
@JsMethod
public static double maximumComponent(Cartesian2 cartesian)
```
    Computes the value of the maximum component for the supplied Cartesian.
    
    Parameters:
    
    cartesian - The cartesian to use.
    
    Returns:
    
    The value of the maximum component.
  - minimumByComponent
```
@JsMethod
public static Cartesian2 minimumByComponent(Cartesian2 first,
                                                      Cartesian2 second,
                                                      Cartesian2 result)
```
    Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
    
    Parameters:
    
    first - A cartesian to compare.
    
    second - A cartesian to compare.
    
    result - The object into which to store the result.
    
    Returns:
    
    A cartesian with the minimum components.
  - minimumComponent
```
@JsMethod
public static double minimumComponent(Cartesian2 cartesian)
```
    Computes the value of the minimum component for the supplied Cartesian.
    
    Parameters:
    
    cartesian - The cartesian to use.
    
    Returns:
    
    The value of the minimum component.
  - mostOrthogonalAxis
```
@JsMethod
public static Cartesian2 mostOrthogonalAxis(Cartesian2 cartesian,
                                                      Cartesian2 result)
```
    Returns the axis that is most orthogonal to the provided Cartesian.
    
    Parameters:
    
    cartesian - The Cartesian on which to find the most orthogonal axis.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The most orthogonal axis.
  - multiplyByScalar
```
@JsMethod
public static Cartesian2 multiplyByScalar(Cartesian2 cartesian,
                                                    double scalar,
                                                    Cartesian2 result)
```
    Multiplies the provided Cartesian componentwise by the provided scalar.
    
    Parameters:
    
    cartesian - The Cartesian to be scaled.
    
    scalar - The scalar to multiply with.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - multiplyComponents
```
@JsMethod
public static Cartesian2 multiplyComponents(Cartesian2 left,
                                                      Cartesian2 right,
                                                      Cartesian2 result)
```
    Computes the componentwise product of two Cartesians.
    
    Parameters:
    
    left - The first Cartesian.
    
    right - The second Cartesian.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - negate
```
@JsMethod
public static Cartesian2 negate(Cartesian2 cartesian,
                                          Cartesian2 result)
```
    Negates the provided Cartesian.
    
    Parameters:
    
    cartesian - The Cartesian to be negated.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - normalize
```
@JsMethod
public static Cartesian2 normalize(Cartesian2 cartesian,
                                             Cartesian2 result)
```
    Computes the normalized form of the supplied Cartesian.
    
    Parameters:
    
    cartesian - The Cartesian to be normalized.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - pack
```
@JsMethod
public static com.google.gwt.core.client.JsArrayNumber pack(Cartesian2 value,
                                                                      com.google.gwt.core.client.JsArrayNumber array,
                                                                      int startingIndex)
```
    Stores the provided instance into the provided array.
    
    Parameters:
    
    value - The value to pack.
    
    array - The array to pack into.
    
    startingIndex - The index into the array at which to start packing the elements. Optional.
    
    Returns:
    
    The array that was packed into
  - packArray
```
@JsMethod
public static com.google.gwt.core.client.JsArrayNumber packArray(Cartesian2[] array,
                                                                           com.google.gwt.core.client.JsArrayNumber result)
```
    Flattens an array of Cartesian2s into and array of components.
    
    Parameters:
    
    array - The array of cartesians to pack.
    
    result - The array onto which to store the result.
    
    Returns:
    
    The packed array.
  - subtract
```
@JsMethod
public static Cartesian2 subtract(Cartesian2 left,
                                            Cartesian2 right,
                                            Cartesian2 result)
```
    Computes the componentwise difference of two Cartesians.
    
    Parameters:
    
    left - The first Cartesian.
    
    right - The second Cartesian.
    
    result - The object onto which to store the result.
    
    Returns:
    
    The modified result parameter.
  - unpack
```
@JsMethod
public static Cartesian2 unpack(com.google.gwt.core.client.JsArrayNumber array)
```
    Retrieves an instance from a packed array.
    
    Parameters:
    
    array - The packed array.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - unpack
```
@JsMethod
public static Cartesian2 unpack(com.google.gwt.core.client.JsArrayNumber array,
                                          int startingIndex,
                                          Cartesian2 result)
```
    Retrieves an instance from a packed array.
    
    Parameters:
    
    array - The packed array.
    
    startingIndex - The starting index of the element to be unpacked. Optional. Default 0.
    
    result - The object into which to store the result. Optional.
    
    Returns:
    
    The modified result parameter or a new Cartesian2 instance if one was not provided.
  - unpackArray
```
@JsMethod
public static Cartesian2[] unpackArray(com.google.gwt.core.client.JsArrayNumber array,
                                                 Cartesian2[] result)
```
    Unpacks an array of cartesian components into and array of Cartesian2s.
    
    Parameters:
    
    array - The array of components to unpack.
    
    result - The array onto which to store the result.
    
    Returns:
    
    The unpacked array.

Class Cartesian2

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

x

y

packedLength

Constructor Detail

Cartesian2

Cartesian2

Method Detail

UNIT_X

UNIT_Y

ZERO

clone

clone

equals

equalsEpsilon

toString

abs

add

angleBetween

clone

distance

distanceSquared

divideByScalar

divideComponents

dot

equals

equalsEpsilon

fromArray

fromArray

fromArray

fromArray

fromCartesian3

fromCartesian4

fromElements

lerp

magnitude

magnitudeSquared

maximumByComponent

maximumComponent

minimumByComponent

minimumComponent

mostOrthogonalAxis

multiplyByScalar

multiplyComponents

negate

normalize

pack

packArray

subtract

unpack

unpack

unpackArray