Cartesian4

一个四维笛卡尔点。

new Cesium.Cartesian4(x, y, z, w)
engine/Source/Core/Cartesian4.js 17

Name Type Default Description
x number 0.0 optional X 分量。
y number 0.0 optional Y 分量。
z number 0.0 optional Z 分量。
w number 0.0 optional W 分量。
See:

Members

w : number
engine/Source/Core/Cartesian4.js 51

W 分量。
Default Value: 0.0

x : number
engine/Source/Core/Cartesian4.js 30

X 分量。
Default Value: 0.0

y : number
engine/Source/Core/Cartesian4.js 37

Y 分量。
Default Value: 0.0

z : number
engine/Source/Core/Cartesian4.js 44

Z 分量。
Default Value: 0.0

static constant Cesium.Cartesian4.ONE : Cartesian4
engine/Source/Core/Cartesian4.js 936

一个不可变的 Cartesian4 实例，初始化为 (1.0, 1.0, 1.0, 1.0)。

static Cesium.Cartesian4.packedLength : number
engine/Source/Core/Cartesian4.js 894

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

static constant Cesium.Cartesian4.UNIT_W : Cartesian4
engine/Source/Core/Cartesian4.js 968

一个不可变的 Cartesian4 实例，初始化为 (0.0, 0.0, 0.0, 1.0)。

static constant Cesium.Cartesian4.UNIT_X : Cartesian4
engine/Source/Core/Cartesian4.js 944

一个不可变的 Cartesian4 实例，初始化为 (1.0, 0.0, 0.0, 0.0)。

static constant Cesium.Cartesian4.UNIT_Y : Cartesian4
engine/Source/Core/Cartesian4.js 952

一个不可变的 Cartesian4 实例，初始化为 (0.0, 1.0, 0.0, 0.0)。

static constant Cesium.Cartesian4.UNIT_Z : Cartesian4
engine/Source/Core/Cartesian4.js 960

一个不可变的 Cartesian4 实例，初始化为 (0.0, 0.0, 1.0, 0.0)。

static constant Cesium.Cartesian4.ZERO : Cartesian4
engine/Source/Core/Cartesian4.js 928

一个不可变的 Cartesian4 实例，初始化为 (0.0, 0.0, 0.0, 0.0)。

Methods

clone(result) → Cartesian4
engine/Source/Core/Cartesian4.js 784

复制此 Cartesian4 实例。
Name Type Description
result Cartesian4 optional 用于存储结果的对象。
Returns:
修改后的 result 参数，或如果未提供，则返回一个新的 Cartesian4 实例。

equals(right) → boolean
engine/Source/Core/Cartesian4.js 795

将此笛卡尔坐标与提供的笛卡尔坐标按分量进行比较并返回 如果它们相等，则为 true，否则为 false。
Name Type Description
right Cartesian4 optional 右侧的笛卡尔坐标。
Returns:
如果它们相等则返回 true，否则返回 false。

equalsEpsilon(right, relativeEpsilon, absoluteEpsilon) → boolean
engine/Source/Core/Cartesian4.js 809

将此笛卡尔坐标与提供的笛卡尔坐标按分量进行比较并返回 true 如果它们通过了绝对或相对容差测试， 否则为 false。
Name Type Default Description
right Cartesian4 optional 右侧的笛卡尔坐标。
relativeEpsilon number 0 optional 用于相等性测试的相对 epsilon 容差。
absoluteEpsilon number relativeEpsilon optional 用于相等性测试的绝对 epsilon 容差g.
Returns:
如果它们在提供的 epsilon 范围内，返回 true；否则返回 false。

toString() → string
engine/Source/Core/Cartesian4.js 823

创建一个字符串，表示该笛卡尔坐标，格式为“(x, y, z, w)”。
Returns:
一个字符串，表示提供的笛卡尔坐标，格式为“(x, y, z, w)”。

static Cesium.Cartesian4.abs(cartesian, result) → Cartesian4
engine/Source/Core/Cartesian4.js 623

计算提供的笛卡尔坐标的绝对值。
Name Type Description
cartesian Cartesian4 要计算绝对值的笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
已修改的结果参数。

static Cesium.Cartesian4.add(left, right, result) → Cartesian4
engine/Source/Core/Cartesian4.js 516

计算两个笛卡尔坐标的分量和。
Name Type Description
left Cartesian4 第一个笛卡尔坐标。
right Cartesian4 第二个笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.clamp(value, min, max, result) → Cartesian4
engine/Source/Core/Cartesian4.js 316

将一个值限制在两个值之间。
Name Type Description
value Cartesian4 要限制的值。
min Cartesian4 最小边界。
max Cartesian4 最大边界。
result Cartesian4 用于存储结果的对象。
Returns:
被限制后的值，使得 min <= result <= max。

static Cesium.Cartesian4.clone(cartesian, result) → Cartesian4
engine/Source/Core/Cartesian4.js 105

复制一个 Cartesian4 实例。
Name Type Description
cartesian Cartesian4 要复制的 Cartesian 对象。
result Cartesian4 optional 用于存储结果的对象。
Returns:
修改后的 result 参数，或者如果未提供则返回一个新的 Cartesian4 实例。（如果 cartesian 未定义，则返回 undefined）

static Cesium.Cartesian4.distance(left, right) → number
engine/Source/Core/Cartesian4.js 379

计算两点之间的四维空间距离。
Name Type Description
left Cartesian4 要计算距离的第一个点。
right Cartesian4 要计算距离的第二个点。
Returns:
两点之间的距离。
Example:
// Returns 1.0
const d = Cesium.Cartesian4.distance(
  new Cesium.Cartesian4(1.0, 0.0, 0.0, 0.0),
  new Cesium.Cartesian4(2.0, 0.0, 0.0, 0.0));

static Cesium.Cartesian4.distanceSquared(left, right) → number
engine/Source/Core/Cartesian4.js 402

计算两点之间的平方距离。使用此函数比较平方距离比使用 Cartesian4#distance 比较距离更高效。
Name Type Description
left Cartesian4 要计算距离的第一个点。
right Cartesian4 要计算到的第二个点。
Returns:
两点之间的距离。
Example:
// Returns 4.0, not 2.0
const d = Cesium.Cartesian4.distance(
  new Cesium.Cartesian4(1.0, 0.0, 0.0, 0.0),
  new Cesium.Cartesian4(3.0, 0.0, 0.0, 0.0));

static Cesium.Cartesian4.divideByScalar(cartesian, scalar, result) → Cartesian4
engine/Source/Core/Cartesian4.js 582

将提供的笛卡尔坐标按分量除以给定的标量。
Name Type Description
cartesian Cartesian4 要被除的笛卡尔坐标。
scalar number 要除以的标量。
result Cartesian4 存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.divideComponents(left, right, result) → Cartesian4
engine/Source/Core/Cartesian4.js 494

计算两个笛卡尔坐标的分量商。
Name Type Description
left Cartesian4 第一个笛卡尔坐标。
right Cartesian4 第二个笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.dot(left, right) → number
engine/Source/Core/Cartesian4.js 453

计算两个笛卡尔坐标的点（标量）积。
Name Type Description
left Cartesian4 第一个笛卡尔坐标。
right Cartesian4 第二个笛卡尔坐标。
Returns:
点积。

static Cesium.Cartesian4.equals(left, right) → boolean
engine/Source/Core/Cartesian4.js 709

按分量比较提供的笛卡尔坐标，并返回 true 如果它们相等，否则返回 false。
Name Type Description
left Cartesian4 optional 第一个笛卡尔坐标。
right Cartesian4 optional 第二个笛卡尔坐标。
Returns:
如果 left 和 right 相等返回 true，否则返回 false。

static Cesium.Cartesian4.equalsEpsilon(left, right, relativeEpsilon, absoluteEpsilon) → boolean
engine/Source/Core/Cartesian4.js 746

分别比较提供的笛卡尔坐标的各个分量，如果它们通过绝对或相对容差测试，返回 true，否则返回 false。
Name Type Default Description
left Cartesian4 optional 第一个笛卡尔坐标。
right Cartesian4 optional 第二个笛卡尔坐标。
relativeEpsilon number 0 optional 用于相等性测试的相对 epsilon 容差。
absoluteEpsilon number relativeEpsilon optional 用于相等性测试的绝对 epsilon 容差。
Returns:
如果 left 和 right 在提供的 epsilon 范围内返回 true，否则返回 false。

static Cesium.Cartesian4.fromArray(array, startingIndex, result) → Cartesian4
engine/Source/Core/Cartesian4.js 914

从数组中的四个连续元素创建一个 Cartesian4。
Name Type Default Description
array Array.<number> 四个连续的元素分别对应 x、y、z 和 w 分量的数组nts, respectively.
startingIndex number 0 optional 数组中第一个元素的偏移量，对应于 x component.
result Cartesian4 optional 存储结果的对象。
Returns:
修改后的结果参数，如果未提供则返回一个新的 Cartesian4 实例。
Example:
// Create a Cartesian4 with (1.0, 2.0, 3.0, 4.0)
const v = [1.0, 2.0, 3.0, 4.0];
const p = Cesium.Cartesian4.fromArray(v);

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

static Cesium.Cartesian4.fromColor(color, result) → Cartesian4
engine/Source/Core/Cartesian4.js 83

从 Color 创建一个 Cartesian4 实例。red、green、blue 和 alpha 分别映射到 x、y、z 和 w。
Name Type Description
color Color 源颜色。
result Cartesian4 optional 用于存储结果的对象。
Returns:
修改后的 result 参数，或者如果未提供则返回一个新的 Cartesian4 实例。

static Cesium.Cartesian4.fromElements(x, y, z, w, result) → Cartesian4
engine/Source/Core/Cartesian4.js 64

从 x、y、z 和 w 坐标创建一个 Cartesian4 实例。
Name Type Description
x number x 坐标。
y number y 坐标。
z number z 坐标。
w number w 坐标。
result Cartesian4 optional 存储结果的对象。
Returns:
修改后的 result 参数，如果未提供则返回一个新的 Cartesian4 实例。

static Cesium.Cartesian4.lerp(start, end, t, result) → Cartesian4
engine/Source/Core/Cartesian4.js 645

使用提供的笛卡尔坐标计算 t 时的线性插值或外推。
Name Type Description
start Cartesian4 对应 t 为 0.0 的值。
end Cartesian4 对应 t 为 1.0 的值。
t number 要进行插值的 t 点。
result Cartesian4 存储结果的对象。
Returns:
修改后的 result 参数。

static Cesium.Cartesian4.magnitude(cartesian) → number
engine/Source/Core/Cartesian4.js 362

计算笛卡尔坐标的大小（长度）。
Name Type Description
cartesian Cartesian4 要计算其大小的笛卡尔实例。
Returns:
大小。

static Cesium.Cartesian4.magnitudeSquared(cartesian) → number
engine/Source/Core/Cartesian4.js 343

计算提供的笛卡尔坐标的平方模。
Name Type Description
cartesian Cartesian4 要计算平方模的笛卡尔实例。
Returns:
平方模。

static Cesium.Cartesian4.maximumByComponent(first, second, result) → Cartesian4
engine/Source/Core/Cartesian4.js 292

比较两个笛卡尔坐标，并计算一个包含所提供笛卡尔坐标最大分量的笛卡尔坐标。
Name Type Description
first Cartesian4 要比较的笛卡尔坐标。
second Cartesian4 要比较的笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
一个具有最大分量的笛卡尔坐标。

static Cesium.Cartesian4.maximumComponent(cartesian) → number
engine/Source/Core/Cartesian4.js 239

计算所提供笛卡尔坐标的最大分量值。
Name Type Description
cartesian Cartesian4 要使用的笛卡尔坐标。
Returns:
最大分量的值。

static Cesium.Cartesian4.minimumByComponent(first, second, result) → Cartesian4
engine/Source/Core/Cartesian4.js 269

比较两个笛卡尔坐标，并计算一个包含所提供笛卡尔坐标最小分量的笛卡尔坐标。
Name Type Description
first Cartesian4 要比较的第一个笛卡尔坐标。
second Cartesian4 要比较的第二个笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
具有最小分量的笛卡尔坐标。

static Cesium.Cartesian4.minimumComponent(cartesian) → number
engine/Source/Core/Cartesian4.js 253

计算所提供笛卡尔坐标的最小分量值。
Name Type Description
cartesian Cartesian4 要使用的笛卡尔坐标。
Returns:
最小分量的值。

static Cesium.Cartesian4.mostOrthogonalAxis(cartesian, result) → Cartesian4
engine/Source/Core/Cartesian4.js 665

返回与提供的笛卡尔坐标最正交的轴。
Name Type Description
cartesian Cartesian4 要查找最正交轴的笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
最正交的轴。

static Cesium.Cartesian4.multiplyByScalar(cartesian, scalar, result) → Cartesian4
engine/Source/Core/Cartesian4.js 560

将提供的笛卡尔坐标按分量与提供的标量相乘。
Name Type Description
cartesian Cartesian4 要缩放的笛卡尔坐标。
scalar number 要相乘的标量。
result Cartesian4 用于存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.multiplyComponents(left, right, result) → Cartesian4
engine/Source/Core/Cartesian4.js 472

计算两个笛卡尔坐标的分量乘积。
Name Type Description
left Cartesian4 第一个笛卡尔坐标。
right Cartesian4 第二个笛卡尔坐标。
result Cartesian4 存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.negate(cartesian, result) → Cartesian4
engine/Source/Core/Cartesian4.js 603

对所提供的笛卡尔坐标取反。
Name Type Description
cartesian Cartesian4 要取反的笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.normalize(cartesian, result) → Cartesian4
engine/Source/Core/Cartesian4.js 419

计算提供的笛卡尔向量的归一化形式。
Name Type Description
cartesian Cartesian4 要归一化的笛卡尔向量。
result Cartesian4 用于存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.pack(value, array, startingIndex) → Array.<number>|Float64Array|Float32Array
engine/Source/Core/Cartesian4.js 130

将提供的实例存储到提供的数组中。
Name Type Default Description
value Cartesian4 要打包的值。
array Array.<number> | Float64Array | Float32Array 要打包到的数组。
startingIndex number 0 optional 开始打包元素的数组索引。
Returns:
被打包的数组

static Cesium.Cartesian4.packArray(array, result) → Array.<number>|Float64Array|Float32Array
engine/Source/Core/Cartesian4.js 178

将一个 Cartesian4 数组展平为一个分量数组。
Name Type Description
array Array.<Cartesian4> 要打包的笛卡尔数组。
result Array.<number> | Float64Array | Float32Array optional 用于存储结果的数组。如果这是一个类型化数组，它必须有 array.length * 4 个分量，否则会抛出 DeveloperError。如果是普通数组，它将被调整大小以包含 (array.length * 4) 个元素。
Returns:
打包后的数组。

static Cesium.Cartesian4.packFloat(value, result) → Cartesian4
engine/Source/Core/Cartesian4.js 834

将任意浮点值打包为可使用 uint8 表示的 4 个值。
Name Type Description
value number 一个浮点数。
result Cartesian4 optional 将包含打包浮点数的 Cartesian4。
Returns:
返回一个 Cartesian4，表示打包到 x、y、z 和 w 的浮点值。

static Cesium.Cartesian4.subtract(left, right, result) → Cartesian4
engine/Source/Core/Cartesian4.js 538

计算两个笛卡尔坐标的分量差。
Name Type Description
left Cartesian4 第一个笛卡尔坐标。
right Cartesian4 第二个笛卡尔坐标。
result Cartesian4 用于存储结果的对象。
Returns:
修改后的结果参数。

static Cesium.Cartesian4.unpack(array, startingIndex, result) → Cartesian4
engine/Source/Core/Cartesian4.js 154

从打包数组中获取一个实例。
Name Type Default Description
array Array.<number> | Float64Array | Float32Array 打包数组。
startingIndex number 0 optional 要解包的元素的起始索引。
result Cartesian4 optional 用于存储结果的对象。
Returns:
修改后的结果参数，或者如果未提供则返回一个新的 Cartesian4 实例。

static Cesium.Cartesian4.unpackArray(array, result) → Array.<Cartesian4>
engine/Source/Core/Cartesian4.js 210

将笛卡尔分量数组解包为 Cartesian4 数组。
Name Type Description
array Array.<number> | Float64Array | Float32Array 要解包的分量数组。
result Array.<Cartesian4> optional 存储结果的数组。
Returns:
解包后的数组。
Need help? The fastest way to get answers is from the community and team on the Cesium Forum.
CtrlK
packages/engine
packages/widgets