Class: Cartesian3

Cartesian3

new Cartesian3(xopt, yopt, zopt)

A 3D Cartesian point.
Parameters:
Name Type Attributes Default Description
x Number <optional>
 0.0 The X component.
y Number <optional>
 0.0 The Y component.
z Number <optional>
 0.0 The Z component.
Source:
See:

Members

x :Number

The X component.
Type:
  • Number
Default Value:
  • 0.0
Source:

y :Number

The Y component.
Type:
  • Number
Default Value:
  • 0.0
Source:

z :Number

The Z component.
Type:
  • Number
Default Value:
  • 0.0
Source:

(static) packedLength :Number

The number of elements used to pack the object into an array.
Type:
  • Number
Source:

(static, constant) UNIT_X :Cartesian3

An immutable Cartesian3 instance initialized to (1.0, 0.0, 0.0).
Type:
Source:

(static, constant) UNIT_Y :Cartesian3

An immutable Cartesian3 instance initialized to (0.0, 1.0, 0.0).
Type:
Source:

(static, constant) UNIT_Z :Cartesian3

An immutable Cartesian3 instance initialized to (0.0, 0.0, 1.0).
Type:
Source:

(static, constant) ZERO :Cartesian3

An immutable Cartesian3 instance initialized to (0.0, 0.0, 0.0).
Type:
Source:

Methods

clone(resultopt) → {Cartesian3}

Duplicates this Cartesian3 instance.
Parameters:
Name Type Attributes Description
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided.
Type
Cartesian3

equals(rightopt) → {Boolean}

Compares this Cartesian against the provided Cartesian componentwise and returns true if they are equal, false otherwise.
Parameters:
Name Type Attributes Description
right Cartesian3 <optional>
 The right hand side Cartesian.
Source:
Returns:
true if they are equal, false otherwise.
Type
Boolean

equalsEpsilon(rightopt, relativeEpsilon, absoluteEpsilonopt) → {Boolean}

Compares this Cartesian against the provided Cartesian componentwise and returns true if they pass an absolute or relative tolerance test, false otherwise.
Parameters:
Name Type Attributes Default Description
right Cartesian3 <optional>
 The right hand side Cartesian.
relativeEpsilon Number The relative epsilon tolerance to use for equality testing.
absoluteEpsilon Number <optional>
 relativeEpsilon The absolute epsilon tolerance to use for equality testing.
Source:
Returns:
true if they are within the provided epsilon, false otherwise.
Type
Boolean

toString() → {String}

Creates a string representing this Cartesian in the format '(x, y, z)'.
Source:
Returns:
A string representing this Cartesian in the format '(x, y, z)'.
Type
String

(static) abs(cartesian, result) → {Cartesian3}

Computes the absolute value of the provided Cartesian.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian whose absolute value is to be computed.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) add(left, right, result) → {Cartesian3}

Computes the componentwise sum of two Cartesians.
Parameters:
Name Type Description
left Cartesian3 The first Cartesian.
right Cartesian3 The second Cartesian.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) angleBetween(left, right) → {Number}

Returns the angle, in radians, between the provided Cartesians.
Parameters:
Name Type Description
left Cartesian3 The first Cartesian.
right Cartesian3 The second Cartesian.
Source:
Returns:
The angle between the Cartesians.
Type
Number

(static) clone(cartesian, resultopt) → {Cartesian3}

Duplicates a Cartesian3 instance.
Parameters:
Name Type Attributes Description
cartesian Cartesian3 The Cartesian to duplicate.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided. (Returns undefined if cartesian is undefined)
Type
Cartesian3

(static) cross(left, right, result) → {Cartesian3}

Computes the cross (outer) product of two Cartesians.
Parameters:
Name Type Description
left Cartesian3 The first Cartesian.
right Cartesian3 The second Cartesian.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The cross product.
Type
Cartesian3

(static) distance(left, right) → {Number}

Computes the distance between two points.
Parameters:
Name Type Description
left Cartesian3 The first point to compute the distance from.
right Cartesian3 The second point to compute the distance to.
Source:
Returns:
The distance between two points.
Type
Number
Example
// Returns 1.0
var d = Cesium.Cartesian3.distance(new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(2.0, 0.0, 0.0));

(static) distanceSquared(left, right) → {Number}

Computes the squared distance between two points. Comparing squared distances using this function is more efficient than comparing distances using Cartesian3#distance.
Parameters:
Name Type Description
left Cartesian3 The first point to compute the distance from.
right Cartesian3 The second point to compute the distance to.
Source:
Returns:
The distance between two points.
Type
Number
Example
// Returns 4.0, not 2.0
var d = Cesium.Cartesian3.distanceSquared(new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(3.0, 0.0, 0.0));

(static) divideByScalar(cartesian, scalar, result) → {Cartesian3}

Divides the provided Cartesian componentwise by the provided scalar.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian to be divided.
scalar Number The scalar to divide by.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) dot(left, right) → {Number}

Computes the dot (scalar) product of two Cartesians.
Parameters:
Name Type Description
left Cartesian3 The first Cartesian.
right Cartesian3 The second Cartesian.
Source:
Returns:
The dot product.
Type
Number

(static) equals(leftopt, rightopt) → {Boolean}

Compares the provided Cartesians componentwise and returns true if they are equal, false otherwise.
Parameters:
Name Type Attributes Description
left Cartesian3 <optional>
 The first Cartesian.
right Cartesian3 <optional>
 The second Cartesian.
Source:
Returns:
true if left and right are equal, false otherwise.
Type
Boolean

(static) equalsEpsilon(leftopt, rightopt, relativeEpsilon, absoluteEpsilonopt) → {Boolean}

Compares the provided Cartesians componentwise and returns true if they pass an absolute or relative tolerance test, false otherwise.
Parameters:
Name Type Attributes Default Description
left Cartesian3 <optional>
 The first Cartesian.
right Cartesian3 <optional>
 The second Cartesian.
relativeEpsilon Number The relative epsilon tolerance to use for equality testing.
absoluteEpsilon Number <optional>
 relativeEpsilon The absolute epsilon tolerance to use for equality testing.
Source:
Returns:
true if left and right are within the provided epsilon, false otherwise.
Type
Boolean

(static) fromArray(array, startingIndexopt, resultopt) → {Cartesian3}

Creates a Cartesian3 from three consecutive elements in an array.
Parameters:
Name Type Attributes Default Description
array Array.<Number> The array whose three consecutive elements correspond to the x, y, and z components, respectively.
startingIndex Number <optional>
 0 The offset into the array of the first element, which corresponds to the x component.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided.
Type
Cartesian3
Example
// Create a Cartesian3 with (1.0, 2.0, 3.0)
var v = [1.0, 2.0, 3.0];
var p = Cesium.Cartesian3.fromArray(v);

// Create a Cartesian3 with (1.0, 2.0, 3.0) using an offset into an array
var v2 = [0.0, 0.0, 1.0, 2.0, 3.0];
var p2 = Cesium.Cartesian3.fromArray(v2, 2);

(static) fromCartesian4(cartesian, resultopt) → {Cartesian3}

Creates a Cartesian3 instance from an existing Cartesian4. This simply takes the x, y, and z properties of the Cartesian4 and drops w.
Parameters:
Name Type Attributes Description
cartesian Cartesian4 The Cartesian4 instance to create a Cartesian3 instance from.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided.
Type
Cartesian3

(static) fromDegrees(longitude, latitude, heightopt, ellipsoidopt, resultopt) → {Cartesian3}

Returns a Cartesian3 position from longitude and latitude values given in degrees.
Parameters:
Name Type Attributes Default Description
longitude Number The longitude, in degrees
latitude Number The latitude, in degrees
height Number <optional>
 0.0 The height, in meters, above the ellipsoid.
ellipsoid Ellipsoid <optional>
 Ellipsoid.WGS84 The ellipsoid on which the position lies.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The position
Type
Cartesian3
Example
var position = Cesium.Cartesian3.fromDegrees(-115.0, 37.0);

(static) fromDegreesArray(coordinates, ellipsoidopt, resultopt) → {Array.<Cartesian3>}

Returns an array of Cartesian3 positions given an array of longitude and latitude values given in degrees.
Parameters:
Name Type Attributes Default Description
coordinates Array.<Number> A list of longitude and latitude values. Values alternate [longitude, latitude, longitude, latitude...].
ellipsoid Ellipsoid <optional>
 Ellipsoid.WGS84 The ellipsoid on which the coordinates lie.
result Array.<Cartesian3> <optional>
 An array of Cartesian3 objects to store the result.
Source:
Returns:
The array of positions.
Type
Array.<Cartesian3>
Example
var positions = Cesium.Cartesian3.fromDegreesArray([-115.0, 37.0, -107.0, 33.0]);

(static) fromDegreesArrayHeights(coordinates, ellipsoidopt, resultopt) → {Array.<Cartesian3>}

Returns an array of Cartesian3 positions given an array of longitude, latitude and height values where longitude and latitude are given in degrees.
Parameters:
Name Type Attributes Default Description
coordinates Array.<Number> A list of longitude, latitude and height values. Values alternate [longitude, latitude, height, longitude, latitude, height...].
ellipsoid Ellipsoid <optional>
 Ellipsoid.WGS84 The ellipsoid on which the position lies.
result Array.<Cartesian3> <optional>
 An array of Cartesian3 objects to store the result.
Source:
Returns:
The array of positions.
Type
Array.<Cartesian3>
Example
var positions = Cesium.Cartesian3.fromDegreesArrayHeights([-115.0, 37.0, 100000.0, -107.0, 33.0, 150000.0]);

(static) fromElements(x, y, z, resultopt) → {Cartesian3}

Creates a Cartesian3 instance from x, y and z coordinates.
Parameters:
Name Type Attributes Description
x Number The x coordinate.
y Number The y coordinate.
z Number The z coordinate.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided.
Type
Cartesian3

(static) fromRadians(longitude, latitude, heightopt, ellipsoidopt, resultopt) → {Cartesian3}

Returns a Cartesian3 position from longitude and latitude values given in radians.
Parameters:
Name Type Attributes Default Description
longitude Number The longitude, in radians
latitude Number The latitude, in radians
height Number <optional>
 0.0 The height, in meters, above the ellipsoid.
ellipsoid Ellipsoid <optional>
 Ellipsoid.WGS84 The ellipsoid on which the position lies.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The position
Type
Cartesian3
Example
var position = Cesium.Cartesian3.fromRadians(-2.007, 0.645);

(static) fromRadiansArray(coordinates, ellipsoidopt, resultopt) → {Array.<Cartesian3>}

Returns an array of Cartesian3 positions given an array of longitude and latitude values given in radians.
Parameters:
Name Type Attributes Default Description
coordinates Array.<Number> A list of longitude and latitude values. Values alternate [longitude, latitude, longitude, latitude...].
ellipsoid Ellipsoid <optional>
 Ellipsoid.WGS84 The ellipsoid on which the coordinates lie.
result Array.<Cartesian3> <optional>
 An array of Cartesian3 objects to store the result.
Source:
Returns:
The array of positions.
Type
Array.<Cartesian3>
Example
var positions = Cesium.Cartesian3.fromRadiansArray([-2.007, 0.645, -1.867, .575]);

(static) fromRadiansArrayHeights(coordinates, ellipsoidopt, resultopt) → {Array.<Cartesian3>}

Returns an array of Cartesian3 positions given an array of longitude, latitude and height values where longitude and latitude are given in radians.
Parameters:
Name Type Attributes Default Description
coordinates Array.<Number> A list of longitude, latitude and height values. Values alternate [longitude, latitude, height, longitude, latitude, height...].
ellipsoid Ellipsoid <optional>
 Ellipsoid.WGS84 The ellipsoid on which the position lies.
result Array.<Cartesian3> <optional>
 An array of Cartesian3 objects to store the result.
Source:
Returns:
The array of positions.
Type
Array.<Cartesian3>
Example
var positions = Cesium.Cartesian3.fromRadiansArrayHeights([-2.007, 0.645, 100000.0, -1.867, .575, 150000.0]);

(static) fromSpherical(spherical, resultopt) → {Cartesian3}

Converts the provided Spherical into Cartesian3 coordinates.
Parameters:
Name Type Attributes Description
spherical Spherical The Spherical to be converted to Cartesian3.
result Cartesian3 <optional>
 The object onto which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided.
Type
Cartesian3

(static) lerp(start, end, t, result) → {Cartesian3}

Computes the linear interpolation or extrapolation at t using the provided cartesians.
Parameters:
Name Type Description
start Cartesian3 The value corresponding to t at 0.0.
end Cartesian3 The value corresponding to t at 1.0.
t Number The point along t at which to interpolate.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) magnitude(cartesian) → {Number}

Computes the Cartesian's magnitude (length).
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian instance whose magnitude is to be computed.
Source:
Returns:
The magnitude.
Type
Number

(static) magnitudeSquared(cartesian) → {Number}

Computes the provided Cartesian's squared magnitude.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian instance whose squared magnitude is to be computed.
Source:
Returns:
The squared magnitude.
Type
Number

(static) maximumByComponent(first, second, result) → {Cartesian3}

Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
Parameters:
Name Type Description
first Cartesian3 A cartesian to compare.
second Cartesian3 A cartesian to compare.
result Cartesian3 The object into which to store the result.
Source:
Returns:
A cartesian with the maximum components.
Type
Cartesian3

(static) maximumComponent(cartesian) → {Number}

Computes the value of the maximum component for the supplied Cartesian.
Parameters:
Name Type Description
cartesian Cartesian3 The cartesian to use.
Source:
Returns:
The value of the maximum component.
Type
Number

(static) minimumByComponent(first, second, result) → {Cartesian3}

Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
Parameters:
Name Type Description
first Cartesian3 A cartesian to compare.
second Cartesian3 A cartesian to compare.
result Cartesian3 The object into which to store the result.
Source:
Returns:
A cartesian with the minimum components.
Type
Cartesian3

(static) minimumComponent(cartesian) → {Number}

Computes the value of the minimum component for the supplied Cartesian.
Parameters:
Name Type Description
cartesian Cartesian3 The cartesian to use.
Source:
Returns:
The value of the minimum component.
Type
Number

(static) mostOrthogonalAxis(cartesian, result) → {Cartesian3}

Returns the axis that is most orthogonal to the provided Cartesian.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian on which to find the most orthogonal axis.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The most orthogonal axis.
Type
Cartesian3

(static) multiplyByScalar(cartesian, scalar, result) → {Cartesian3}

Multiplies the provided Cartesian componentwise by the provided scalar.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian to be scaled.
scalar Number The scalar to multiply with.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) multiplyComponents(left, right, result) → {Cartesian3}

Computes the componentwise product of two Cartesians.
Parameters:
Name Type Description
left Cartesian3 The first Cartesian.
right Cartesian3 The second Cartesian.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) negate(cartesian, result) → {Cartesian3}

Negates the provided Cartesian.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian to be negated.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) normalize(cartesian, result) → {Cartesian3}

Computes the normalized form of the supplied Cartesian.
Parameters:
Name Type Description
cartesian Cartesian3 The Cartesian to be normalized.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) pack(value, array, startingIndexopt) → {Array.<Number>}

Stores the provided instance into the provided array.
Parameters:
Name Type Attributes Default Description
value Cartesian3 The value to pack.
array Array.<Number> The array to pack into.
startingIndex Number <optional>
 0 The index into the array at which to start packing the elements.
Source:
Returns:
The array that was packed into
Type
Array.<Number>

(static) packArray(array, result) → {Array.<Number>}

Flattens an array of Cartesian3s into an array of components.
Parameters:
Name Type Description
array Array.<Cartesian3> The array of cartesians to pack.
result Array.<Number> The array onto which to store the result.
Source:
Returns:
The packed array.
Type
Array.<Number>

(static) subtract(left, right, result) → {Cartesian3}

Computes the componentwise difference of two Cartesians.
Parameters:
Name Type Description
left Cartesian3 The first Cartesian.
right Cartesian3 The second Cartesian.
result Cartesian3 The object onto which to store the result.
Source:
Returns:
The modified result parameter.
Type
Cartesian3

(static) unpack(array, startingIndexopt, resultopt) → {Cartesian3}

Retrieves an instance from a packed array.
Parameters:
Name Type Attributes Default Description
array Array.<Number> The packed array.
startingIndex Number <optional>
 0 The starting index of the element to be unpacked.
result Cartesian3 <optional>
 The object into which to store the result.
Source:
Returns:
The modified result parameter or a new Cartesian3 instance if one was not provided.
Type
Cartesian3

(static) unpackArray(array, result) → {Array.<Cartesian3>}

Unpacks an array of cartesian components into an array of Cartesian3s.
Parameters:
Name Type Description
array Array.<Number> The array of components to unpack.
result Array.<Cartesian3> The array onto which to store the result.
Source:
Returns:
The unpacked array.
Type
Array.<Cartesian3>