cesium 开发自学 方法 成员 代码示例演示 坐标 Cartesian2

笛卡尔坐标

Cartesian2

new Cesium.Cartesian2 ( x , y )        

2D笛卡尔点

method：

packedLength 

Cesium.Cartesian2.packedLength        

用于将对象打包到数组中的元素数  这里是 2

UNIT_X 、UNIT_Y 

Cesium.Cartesian2.UNIT_X        Cesium.Cartesian2.UNIT_Y       

用于表达X、Y方向上的单位向量       

这些常量对象可以在 Cesium 的计算和几何操作中使用，例如向量的缩放、旋转、偏移等。由于它们是常量对象，因此可以直接引用，不需要创建新的对象

var vector = new Cesium.Cartesian2(2, 3);

// 将向量乘以 UNIT_X
var scaledVector = Cesium.Cartesian2.multiplyByScalar(vector, Cesium.Cartesian2.UNIT_X, new Cesium.Cartesian2());
console.log(scaledVector);  // 输出：Cartesian2 { x: 2, y: 0 }，向量在 x 轴方向上缩放为原来的两倍

// 将向量旋转 90 度
var rotatedVector = Cesium.Cartesian2.multiplyByScalar(vector, Cesium.Cartesian2.UNIT_Y, new Cesium.Cartesian2());
console.log(rotatedVector);  // 输出：Cartesian2 { x: -3, y: 2 }，向量逆时针旋转了 90 度

ZERO

Cesium.Cartesian2.ZERO

表示一个二维笛卡尔坐标系中的零向量，即坐标为 (0, 0) 的向量

var zeroVector = Cesium.Cartesian2.ZERO;
console.log(zeroVector);  // 输出：Cartesian2 { x: 0, y: 0 }

var vector = new Cesium.Cartesian2(2, 3);

// 将向量重置为零向量
vector = Cesium.Cartesian2.ZERO;
console.log(vector);  // 输出：Cartesian2 { x: 0, y: 0 }

Methods：

equalsEpsilon

equalsEpsilon ( right , relativeEpsilon, absoluteEpsilon ) → Boolean

将此笛卡尔坐标与提供的笛卡尔分量进行比较

参数：

right（可选）：一个 Cartesian2对象，表示要进行比较的点。

relativeEpsilon：一个可选的数字，表示相对误差。默认值为 Cesium.Math.EPSILON10，一个非常小的值。

absoluteEpsilon（可选）：一个可选的数字，表示绝对误差。默认值为 Cesium.Math.EPSILON10

返回值：如果给定的向量或点在指定的误差范围内相等，则返回 true，否则返回 false

var point1 = new Cesium.Cartesian2(1.0, 2.0);
var point2 = new Cesium.Cartesian2(1.000001, 2.000002);

var equal = point1.equalsEpsilon(point2, Cesium.Math.EPSILON1, Cesium.Math.EPSILON2);
console.log(equal);  // 输出：true，point1 和 point2 在给定的误差范围内相等

 

toString

toString () → String

创建一个以'（x，y）'格式表示此笛卡尔坐标的字符串

var vector = new Cesium.Cartesian2(3, 4);
var vectorString = vector.toString();

console.log(vectorString);  // 输出："(3, 4)"

 

abs

Cesium.Cartesian2.abs (cartesian, result) → Cartesian2

计算提供的笛卡尔坐标的绝对值

参数:

cartesian：一个 Cartesian2 对象，表示一个二维向量。

result（可选）：一个 Cartesian2 对象，用于存储计算结果。如果不提供该参数，方法会创建一个新的 Cartesian2 对象来存储结果，并返回该对象

返回值：

一个 Cartesian2 对象，表示输入向量的绝对值（长度）

var cartesian = new Cesium.Cartesian2(3, 4);
var result = new Cesium.Cartesian2();
var absValue = Cesium.Cartesian2.abs(cartesian, result);

console.log(absValue);  // 输出：5
console.log(result);    // 输出：Cartesian2 { x: 3, y: 4 }，result 对象中存储了计算结果

add 

Cesium.Cartesian2.add (left, right, result) → Cartesian2

计算两个笛卡尔的按分量求和

参数：

left：一个 Cartesian2 对象，表示左操作数（第一个向量）。

right：一个 Cartesian2 对象，表示右操作数（第二个向量）。

result（可选）：一个 Cartesian2 对象，用于存储计算结果。如果不提供该参数，方法会创建一个新的 Cartesian2 对象来存储结果，并返回该对象。

返回值：

一个 Cartesian2 对象，表示两个向量相加的结果。

var vector1 = new Cesium.Cartesian2(2, 3);
var vector2 = new Cesium.Cartesian2(1, 1);
var result = new Cesium.Cartesian2();

var sum = Cesium.Cartesian2.add(vector1, vector2, result);

console.log(sum);     // 输出：Cartesian2 { x: 3, y: 4 }，向量相加的结果
console.log(result);  // 输出：Cartesian2 { x: 3, y: 4 }，result 对象中存储了计算结果

subtract

Cesium.Cartesian2.subtract (left, right, result) → Cartesian2

参数：

left：一个 Cartesian2 对象，表示被减数向量。

right：一个 Cartesian2 对象，表示减数向量。

result：一个可选的 Cartesian2 对象，用于存储计算结果。如果提供了 result，则会将计算结果存储在该对象中并返回它。

var vector1 = new Cesium.Cartesian2(3, 5);
var vector2 = new Cesium.Cartesian2(1, 2);

var result = new Cesium.Cartesian2();
Cesium.Cartesian2.subtract(vector1, vector2, result);

console.log(result);  // 输出：Cartesian2 {x: 2, y: 3}

 

angleBetween

Cesium.Cartesian2.angleBetween (left, right) → Number

获取所提供的笛卡尔坐标之间的角度（以弧度为单位）

参数：

left：一个 Cartesian2 对象，表示左操作数（第一个向量）

right：一个 Cartesian2 对象，表示右操作数（第二个向量）

返回值：

一个数字，表示两个向量之间的夹角（以弧度为单位）

var vector1 = new Cesium.Cartesian2(1, 0);
var vector2 = new Cesium.Cartesian2(0, 1);

var angle = Cesium.Cartesian2.angleBetween(vector1, vector2);

console.log(angle);                        // 输出：1.5707963267948966，夹角的弧度值
console.log(Cesium.Math.toDegrees(angle));  // 输出：90，夹角的度数值

distance

Cesium.Cartesian2.distance (left, right) → Number

计算两点之间的距离

参数：

left：一个 Cartesian2 对象，表示左操作数（第一个点）

right：一个 Cartesian2 对象，表示右操作数（第二个点）

返回值：

一个数字，表示两个点之间的距离

var point1 = new Cesium.Cartesian2(1, 2);
var point2 = new Cesium.Cartesian2(4, 6);

var distance = Cesium.Cartesian2.distance(point1, point2);

console.log(distance);  // 输出：5，点之间的距离

magnitude

Cesium.Cartesian2.magnitude (cartesian) → Number

计算笛卡尔的大小（长度）

参数:

cartesian：一个cartesian2对象

返回值：一个Number值，表示到原点的距离

var vector = new Cesium.Cartesian2(3, 4);

var magnitude = Cesium.Cartesian2.magnitude(vector);

console.log(magnitude);  // 输出：5

dot

Cesium.Cartesian2.dot (left, right) → Number

计算两个笛卡尔的点（标量）乘积

参数：

left：一个 Cartesian2 对象

right：另一个 Cartesian2 对象

返回值：一个Number值，表示点积的值

var vector1 = new Cesium.Cartesian2(2, 3);
var vector2 = new Cesium.Cartesian2(-4, 1);

var dotProduct = Cesium.Cartesian2.dot(vector1, vector2);

console.log(dotProduct);  // 输出：-5，点积的值

multiplyByScalar

Cesium.Cartesian2.multiplyByScalar (cartesian, scalar, result) → Cartesian2

将提供的笛卡尔分量乘以提供的标量

参数：

cartesian：一个 Cartesian2 对象，表示要进行乘法运算的向量。

scalar：一个数字，表示要乘以的标量值。

result：可选参数，一个 Cartesian2 对象，用于存储计算结果。如果提供了 result，则会将计算结果存储在该对象中并返回它。

返回值：一个新的Cartesian2 对象

var vector = new Cesium.Cartesian2(2, 3);
var scalar = 2;

var result = new Cesium.Cartesian2();
Cesium.Cartesian2.multiplyByScalar(vector, scalar, result);

console.log(result);  // 输出：Cartesian2 {x: 4, y: 6}

divideByScalar

Cesium.Cartesian2.divideByScalar (cartesian, scalar, result) → Cartesian2

参数：

cartesian：一个 Cartesian2 对象，表示要进行除法运算的向量。

scalar：一个标量值，表示除法运算的除数。

result：一个可选的 Cartesian2 对象，用于存储计算结果。如果提供了 result，则会将计算结果存储在该对象中并返回它。

返回值：一个Cartesian2 对象

var vector = new Cesium.Cartesian2(6, 8);
var scalar = 2;
var result = new Cesium.Cartesian2();

Cesium.Cartesian2.divideByScalar(vector, scalar, result);

console.log(result);  // 输出：Cartesian2 {x: 3, y: 4}

fromArray

Cesium.Cartesian2.fromArray (array, startingIndex , result ) → Cartesian2

从数组中的两个连续元素创建Cartesian2

参数：

array：一个包含坐标值的数组。

startingIndex：可选参数，指定开始提取坐标值的索引，默认为 0。

result：可选参数，用于存储计算结果的 Cartesian2 对象。

返回值：一个Cartesian2 对象

var array = [2, 3];
var result = new Cesium.Cartesian2();

Cesium.Cartesian2.fromArray(array, 0, result);

console.log(result);  // 输出：Cartesian2 {x: 2, y: 3}

var v2 = [0.0, 0.0, 1.0, 2.0];

var result = new Cesium.Cartesian2();

var p2 = Cesium.Cartesian2.fromArray(v2, 2, result);

console.log(result);  // 输出：Cartesian2 {x: 1.0, y: 2.0}

normalize

Cesium.Cartesian2.normalize (cartesian, result) → Cartesian2

计算提供的笛卡尔坐标系的标准化形式

归一化是将向量的长度缩放为1的过程，从而得到一个方向相同但长度为1的单位向量

参数：

cartesian：一个 Cartesian2 对象，表示要进行归一化的向量。

result：一个可选的 Cartesian2 对象，用于存储计算结果。如果提供了 result，则会将计算结果存储在该对象中并返回它

返回值：一个归一化后的Cartesian2 对象

var vector = new Cesium.Cartesian2(3, 4);
var result = new Cesium.Cartesian2();

Cesium.Cartesian2.normalize(vector, result);

console.log(result);  // 输出：Cartesian2 {x: 0.6, y: 0.8}