@lijuhong1981/cesium.utils 0.0.0-stage → 0.1.0

package/src/additions/index.js

@@ -0,0 +1,8 @@
+export * from "./Geographic.js";
+export * from "./GeometryInstanceAttributes.js";
+export * from "./GeographicTransform.js";
+export * from "./ModelMatrixTransforms.js";
+export * from "./StTransforms.js";
+export * from "./TranslationRotationScaleTransform.js";
+export * from "./PropertyChangedListener.js";
+export * from "./PropertyType.js";

package/src/index.js

@@ -0,0 +1,4 @@
+export * from "./revisions/index.js";
+export * from "./parses/index.js";
+export * from "./utils/index.js";
+export * from "./additions/index.js";

package/src/parses/index.js

@@ -0,0 +1,46 @@
+export * from "./parseAltitude.js";
+export * from "./parseArcType.js";
+export * from "./parseAttitudeToHeadingPitchRoll.js";
+export * from "./parseAttitudeToMatrix3.js";
+export * from "./parseAttitudeToQuaternion.js";
+export * from "./parseCartographicsToPositions.js";
+export * from "./parseCartographicToCartesian.js";
+export * from "./parseClassificationType.js";
+export * from "./parseClockRange.js";
+export * from "./parseColorBlendMode.js";
+export * from "./parseCornerType.js";
+export * from "./parseCullFace.js";
+export * from "./parseEulerToHeadingPitchRoll.js";
+export * from "./parseEulerToQuaternion.js";
+export * from "./parseGeographicsToPositions.js";
+export * from "./parseGeographicToCartesian.js";
+export * from "./parseHeading.js";
+export * from "./parseHeightReference.js";
+export * from "./parseHorizontalOrigin.js";
+export * from "./parseLabelStyle.js";
+export * from "./parseLatitude.js";
+export * from "./parseLongitude.js";
+export * from "./parsePitch.js";
+export * from "./parseRoll.js";
+export * from "./parseRotationToHeadingPitchRoll.js";
+export * from "./parseRotationToMatrix3.js";
+export * from "./parseRotationToQuaternion.js";
+export * from "./parseShadowMode.js";
+export * from "./parseToBoundingRectangle.js";
+export * from "./parseToCartesian2.js";
+export * from "./parseToCartesian3.js";
+export * from "./parseToCartesian3Array.js";
+export * from "./parseToCartesian4.js";
+export * from "./parseToCartographic.js";
+export * from "./parseToColor.js";
+export * from "./parseToDistanceDisplayCondition.js";
+export * from "./parseToGeographic.js";
+export * from "./parseToHeadingPitchRange.js";
+export * from "./parseToJulianDate.js";
+export * from "./parseToNearFarScalar.js";
+export * from "./parseToPlane.js";
+export * from "./parseToPolygonHierarchy.js";
+export * from "./parseToRange.js";
+export * from "./parseToRectangle.js";
+export * from "./parseToTimeInterval.js";
+export * from "./parseVerticalOrigin.js";

package/src/parses/parseAltitude.js

@@ -0,0 +1,32 @@
+import parseNumber from '@lijuhong1981/jsmath/src/parseNumber.js';
+
+/**
+ * 把数字、字符串或含高度信息的数组/对象解析为高度值。
+ * @param {number|string|Array|object} value 待解析的值，支持以第 2 个分量表示的数组或含 altitude/alt/height/Alt 字段的对象
+ * @returns {number} 解析后的高度值，无法解析时返回 0
+ */
+function parseAltitude(value) {
+    if (!value)
+        return 0;
+    else if (typeof value === 'number')
+        return value;
+    else if (typeof value === 'string')
+        return parseFloat(value);
+    else if (value[2] !== undefined)
+        return parseNumber(value[2]);
+    else if (value.altitude !== undefined)
+        return parseNumber(value.altitude);
+    else if (value.alt !== undefined)
+        return parseNumber(value.alt);
+    else if (value.height !== undefined)
+        return parseNumber(value.height);
+    else if (value.Alt !== undefined)
+        return parseNumber(value.Alt);
+    // else if (value.z !== undefined)
+    //     return value.z;
+    else
+        return 0;
+}
+
+export default parseAltitude;
+export { parseAltitude, parseAltitude as parseHeight };

package/src/parses/parseArcType.js

@@ -0,0 +1,26 @@
+import { ArcType } from 'cesium';
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link ArcType} 枚举值。
+ * @param {string|number} value 待解析的值，字符串支持 'rhumb'、'geodesic'、'none'
+ * @returns {ArcType} 解析后的 ArcType，无法识别时返回 ArcType.NONE
+ */
+function parseArcType(value) {
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'rhumb':
+                return ArcType.RHUMB;
+            case 'geodesic':
+                return ArcType.GEODESIC;
+            case 'none':
+            default:
+                return ArcType.NONE;
+        }
+    } else if (typeof value === 'number')
+        return value;
+    else
+        return ArcType.NONE;
+};
+
+export default parseArcType;
+export { parseArcType };

package/src/parses/parseAttitudeToHeadingPitchRoll.js

@@ -0,0 +1,26 @@
+import { HeadingPitchRoll } from "cesium";
+import parseHeading from "./parseHeading.js";
+import parsePitch from "./parsePitch.js";
+import parseRoll from "./parseRoll.js";
+
+/**
+ * 把姿态值解析为 {@link HeadingPitchRoll} 对象（角度制）。
+ * @param {HeadingPitchRoll|Array|object|string|number} value 待解析的姿态值
+ * @param {HeadingPitchRoll} [result] 用于存储结果的可选对象
+ * @returns {HeadingPitchRoll} 解析后的 HeadingPitchRoll
+ */
+function parseAttitudeToHeadingPitchRoll(value, result) {
+    if (value instanceof HeadingPitchRoll) {
+        if (result && value !== result)
+            return HeadingPitchRoll.clone(value, result);
+        else
+            return value;
+    }
+    const heading = parseHeading(value);
+    const pitch = parsePitch(value);
+    const roll = parseRoll(value);
+    return HeadingPitchRoll.fromDegrees(heading, pitch, roll, result);
+};
+
+export default parseAttitudeToHeadingPitchRoll;
+export { parseAttitudeToHeadingPitchRoll };

package/src/parses/parseAttitudeToMatrix3.js

@@ -0,0 +1,17 @@
+import { Matrix3 } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseAttitudeToHeadingPitchRoll from "./parseAttitudeToHeadingPitchRoll.js";
+
+/**
+ * 把姿态值解析为 3x3 旋转矩阵（{@link Matrix3}）。
+ * @param {HeadingPitchRoll|Array|object|string|number} attitude 待解析的姿态值
+ * @param {Matrix3} [result] 用于存储结果的可选对象
+ * @returns {Matrix3} 解析后的旋转矩阵
+ */
+function parseAttitudeToMatrix3(attitude, result) {
+    const hpr = parseAttitudeToHeadingPitchRoll(attitude, Scratch.scratchHeadingPitchRoll);
+    return Matrix3.fromHeadingPitchRoll(hpr, result);
+};
+
+export default parseAttitudeToMatrix3;
+export { parseAttitudeToMatrix3 };

package/src/parses/parseAttitudeToQuaternion.js

@@ -0,0 +1,21 @@
+import { Quaternion, Transforms } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseAttitudeToHeadingPitchRoll from "./parseAttitudeToHeadingPitchRoll.js";
+
+/**
+ * 把姿态值解析为四元数（{@link Quaternion}），可指定参考坐标系原点。
+ * @param {HeadingPitchRoll|Array|object|string|number} attitude 待解析的姿态值
+ * @param {Cartesian3} [origin] 参考坐标系原点（地心世界坐标），提供时按该点局部坐标系计算
+ * @param {Quaternion} [result] 用于存储结果的可选对象
+ * @returns {Quaternion} 解析后的四元数
+ */
+function parseAttitudeToQuaternion(attitude, origin, result) {
+    const hpr = parseAttitudeToHeadingPitchRoll(attitude, Scratch.scratchHeadingPitchRoll);
+    if (origin)
+        return Transforms.headingPitchRollQuaternion(origin, hpr, undefined, undefined, result)
+    else
+        return Quaternion.fromHeadingPitchRoll(hpr, result);
+};
+
+export default parseAttitudeToQuaternion;
+export { parseAttitudeToQuaternion };

package/src/parses/parseCartographicToCartesian.js

@@ -0,0 +1,21 @@
+import { Cartesian3 } from "cesium";
+import { parseHeight } from "./parseAltitude.js";
+import parseLatitude from "./parseLatitude.js";
+import parseLongitude from "./parseLongitude.js";
+
+/**
+ * 把地理坐标解析为笛卡尔坐标（{@link Cartesian3}），输入按弧度处理。
+ * @param {Cartographic|Array|object} cartographic 待解析的地理坐标，含经度/纬度/高度信息
+ * @param {Cartesian3} [result] 用于存储结果的可选对象
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Cartesian3} 解析后的笛卡尔坐标
+ */
+function parseCartographicToCartesian(cartographic, result, ellipsoid) {
+    const longitude = parseLongitude(cartographic);
+    const latitude = parseLatitude(cartographic);
+    const height = parseHeight(cartographic);
+    return Cartesian3.fromRadians(longitude, latitude, height, ellipsoid, result);
+};
+
+export default parseCartographicToCartesian;
+export { parseCartographicToCartesian };

package/src/parses/parseCartographicsToPositions.js

@@ -0,0 +1,20 @@
+import { Check } from "cesium";
+import parseCartographicToCartesian from "./parseCartographicToCartesian.js";
+
+/**
+ * 把地理坐标数组批量解析为笛卡尔坐标数组（{@link Cartesian3}），输入按弧度处理。
+ * @param {Array} cartographics 地理坐标数组
+ * @param {Array} [result=[]] 用于存储结果的数组
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Array} 解析后的笛卡尔坐标数组
+ */
+function parseCartographicsToPositions(cartographics, result = [], ellipsoid) {
+    Check.typeOf.array('cartographics', cartographics);
+    for (let i = 0; i < cartographics.length; i++) {
+        result[i] = parseCartographicToCartesian(cartographics[i], result[i], ellipsoid);
+    }
+    return result;
+};
+
+export default parseCartographicsToPositions;
+export { parseCartographicsToPositions };

package/src/parses/parseClassificationType.js

@@ -0,0 +1,24 @@
+import { ClassificationType, DeveloperError } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link ClassificationType} 枚举值。
+ * @param {string|number} value 待解析的值，字符串包含 'terrain' 返回 TERRAIN、包含 '3dtile' 返回 CESIUM_3D_TILE
+ * @returns {ClassificationType} 解析后的 ClassificationType
+ */
+function parseClassificationType(value) {
+    if (typeof value === 'string') {
+        value = value.toLowerCase();
+        if (value.match('terrain'))
+            return ClassificationType.TERRAIN;
+        else if (value.match('3dtile'))
+            return ClassificationType.CESIUM_3D_TILE;
+        else
+            return ClassificationType.BOTH;
+    } else if (typeof value === 'number')
+        return value;
+    else
+        throw new DeveloperError('unable parse the ' + value + ' to ClassificationType.');
+};
+
+export default parseClassificationType;
+export { parseClassificationType };

package/src/parses/parseClockRange.js

@@ -0,0 +1,26 @@
+import { ClockRange, DeveloperError } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link ClockRange} 枚举值。
+ * @param {string|number} value 待解析的值，字符串支持 'clamped'、'loop_stop'、'unbounded'
+ * @returns {ClockRange} 解析后的 ClockRange
+ */
+function parseClockRange(value) {
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'clamped':
+                return ClockRange.CLAMPED;
+            case 'loop_stop':
+                return ClockRange.LOOP_STOP;
+            case 'unbounded':
+            default:
+                return ClockRange.UNBOUNDED;
+        }
+    } else if (typeof value === 'number')
+        return value;
+    else
+        throw new DeveloperError('unable parse the ' + value + ' to ClockRange.');
+};
+
+export default parseClockRange;
+export { parseClockRange };

package/src/parses/parseColorBlendMode.js

@@ -0,0 +1,26 @@
+import { ColorBlendMode, DeveloperError } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link ColorBlendMode} 枚举值。
+ * @param {string|number} value 待解析的值，字符串支持 'replace'、'mix'、'highlight'
+ * @returns {ColorBlendMode} 解析后的 ColorBlendMode
+ */
+function parseColorBlendMode(value) {
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'replace':
+                return ColorBlendMode.REPLACE;
+            case 'mix':
+                return ColorBlendMode.MIX;
+            case 'highlight':
+            default:
+                return ColorBlendMode.HIGHLIGHT;
+        }
+    } else if (typeof value === 'number')
+        return value;
+    else
+        throw new DeveloperError('unable parse the ' + value + ' to ColorBlendMode.');
+};
+
+export default parseColorBlendMode;
+export { parseColorBlendMode };

package/src/parses/parseCornerType.js

@@ -0,0 +1,24 @@
+import { CornerType, DeveloperError } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link CornerType} 枚举值。
+ * @param {string|number} value 待解析的值，字符串包含 'bevel' 返回 BEVELED、包含 'miter' 返回 MITERED
+ * @returns {CornerType} 解析后的 CornerType
+ */
+function parseCornerType(value) {
+    if (typeof value === 'string') {
+        value = value.toLowerCase();
+        if (value.match('bevel'))
+            return CornerType.BEVELED;
+        else if (value.match('miter'))
+            return CornerType.MITERED;
+        else
+            return CornerType.ROUNDED;
+    } else if (typeof value === 'number')
+        return value;
+    else
+        throw new DeveloperError('unable parse the ' + value + ' to CornerType.');
+};
+
+export default parseCornerType;
+export { parseCornerType };

package/src/parses/parseCullFace.js

@@ -0,0 +1,28 @@
+import { CullFace } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link CullFace} 枚举值。
+ * @param {string|number} value 待解析的值，字符串支持 'front'、'back'、'front_and_back'、'none'
+ * @returns {CullFace} 解析后的 CullFace，无法识别时返回 CullFace.NONE
+ */
+function parseCullFace(value) {
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'front':
+                return CullFace.FRONT;
+            case 'back':
+                return CullFace.BACK;
+            case 'front_and_back':
+                return CullFace.FRONT_AND_BACK;
+            case 'none':
+            default:
+                return CullFace.NONE;
+        }
+    } else if (typeof value === 'number')
+        return value;
+    else
+        return CullFace.NONE;
+};
+
+export default parseCullFace;
+export { parseCullFace };

package/src/parses/parseEulerToHeadingPitchRoll.js

@@ -0,0 +1,21 @@
+import { HeadingPitchRoll } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseToCartesian3 from "./parseToCartesian3.js";
+
+/**
+ * 把欧拉角解析为 {@link HeadingPitchRoll} 对象。
+ * @param {Array|object|string|number} value 待解析的欧拉角，按 [roll, pitch, yaw] 顺序
+ * @param {HeadingPitchRoll} [result] 用于存储结果的可选对象
+ * @param {boolean} [isDegrees] 输入是否为角度制，为 true 时按角度解析
+ * @returns {HeadingPitchRoll} 解析后的 HeadingPitchRoll
+ */
+function parseEulerToHeadingPitchRoll(value, result, isDegrees) {
+    value = parseToCartesian3(value, Scratch.scratchCartesian3, 0.0);
+    if (isDegrees)
+        return HeadingPitchRoll.fromDegrees(-value.z, -value.y, value.x, result);
+    else
+        return HeadingPitchRoll.fromRadians(-value.z, -value.y, value.x, result);
+};
+
+export default parseEulerToHeadingPitchRoll;
+export { parseEulerToHeadingPitchRoll };

package/src/parses/parseEulerToQuaternion.js

@@ -0,0 +1,18 @@
+import { Quaternion } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseEulerToHeadingPitchRoll from "./parseEulerToHeadingPitchRoll.js";
+
+/**
+ * 把欧拉角解析为四元数（{@link Quaternion}）。
+ * @param {Array|object|string|number} value 待解析的欧拉角，按 [roll, pitch, yaw] 顺序
+ * @param {Quaternion} [result] 用于存储结果的可选对象
+ * @param {boolean} [isDegrees] 输入是否为角度制，为 true 时按角度解析
+ * @returns {Quaternion} 解析后的四元数
+ */
+function parseEulerToQuaternion(value, result, isDegrees) {
+    const hpr = parseEulerToHeadingPitchRoll(value, Scratch.scratchHeadingPitchRoll, isDegrees);
+    return Quaternion.fromHeadingPitchRoll(hpr, result);
+};
+
+export default parseEulerToQuaternion;
+export { parseEulerToQuaternion };

package/src/parses/parseGeographicToCartesian.js

@@ -0,0 +1,21 @@
+import { Cartesian3 } from "cesium";
+import parseAltitude from "./parseAltitude.js";
+import parseLatitude from "./parseLatitude.js";
+import parseLongitude from "./parseLongitude.js";
+
+/**
+ * 把地理坐标解析为笛卡尔坐标（{@link Cartesian3}），输入按经度/纬度角度制处理。
+ * @param {Array|object} geographic 待解析的地理坐标，含经度/纬度/高度信息
+ * @param {Cartesian3} [result] 用于存储结果的可选对象
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Cartesian3} 解析后的笛卡尔坐标
+ */
+function parseGeographicToCartesian(geographic, result, ellipsoid) {
+    const longitude = parseLongitude(geographic);
+    const latitude = parseLatitude(geographic);
+    const height = parseAltitude(geographic);
+    return Cartesian3.fromDegrees(longitude, latitude, height, ellipsoid, result);
+};
+
+export default parseGeographicToCartesian;
+export { parseGeographicToCartesian };

package/src/parses/parseGeographicsToPositions.js

@@ -0,0 +1,20 @@
+import { Check } from "cesium";
+import parseGeographicToCartesian from "./parseGeographicToCartesian.js";
+
+/**
+ * 把地理坐标数组批量解析为笛卡尔坐标数组（{@link Cartesian3}），输入按角度制处理。
+ * @param {Array} geographics 地理坐标数组
+ * @param {Array} [result=[]] 用于存储结果的数组
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Array} 解析后的笛卡尔坐标数组
+ */
+function parseGeographicsToPositions(geographics, result = [], ellipsoid) {
+    Check.typeOf.array('geographics', geographics);
+    for (let i = 0; i < geographics.length; i++) {
+        result[i] = parseGeographicToCartesian(geographics[i], result[i], ellipsoid);
+    }
+    return result;
+};
+
+export default parseGeographicsToPositions;
+export { parseGeographicsToPositions };

package/src/parses/parseHeading.js

@@ -0,0 +1,28 @@
+/**
+ * 把数字、字符串或数组/对象解析为偏航角（heading）数值。
+ * @param {number|string|Array|object} value 待解析的值，支持第 0 个分量表示的数组或含 heading/yaw/z/Yaw 字段的对象
+ * @returns {number} 解析后的偏航角，无法解析时返回 0
+ */
+function parseHeading(value) {
+    if (value === undefined)
+        return 0;
+    else if (typeof value === 'number')
+        return value;
+    else if (typeof value === 'string')
+        return parseFloat(value);
+    else if (value[0] !== undefined)
+        return value[0];
+    else if (value.heading !== undefined)
+        return value.heading;
+    else if (value.yaw !== undefined)
+        return value.yaw;
+    else if (value.z !== undefined)
+        return value.z;
+    else if (value.Yaw !== undefined)
+        return value.Yaw;
+    else
+        return 0;
+};
+
+export default parseHeading;
+export { parseHeading };

package/src/parses/parseHeightReference.js

@@ -0,0 +1,24 @@
+import { HeightReference } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link HeightReference} 枚举值。
+ * @param {string|number} value 待解析的值，字符串包含 'clamp' 返回 CLAMP_TO_GROUND、包含 'relative' 返回 RELATIVE_TO_GROUND
+ * @returns {HeightReference} 解析后的 HeightReference，无法识别时返回 HeightReference.NONE
+ */
+function parseHeightReference(value) {
+    if (typeof value === 'string') {
+        value = value.toLowerCase();
+        if (value.match('clamp'))
+            return HeightReference.CLAMP_TO_GROUND;
+        else if (value.match('relative'))
+            return HeightReference.RELATIVE_TO_GROUND;
+        else
+            return HeightReference.NONE;
+    } else if (typeof value === 'number')
+        return value;
+    else
+        return HeightReference.NONE;
+};
+
+export default parseHeightReference;
+export { parseHeightReference };

package/src/parses/parseHorizontalOrigin.js

@@ -0,0 +1,26 @@
+import { DeveloperError, HorizontalOrigin } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link HorizontalOrigin} 枚举值。
+ * @param {string|number} value 待解析的值，字符串支持 'left'、'right'、'center'
+ * @returns {HorizontalOrigin} 解析后的 HorizontalOrigin
+ */
+function parseHorizontalOrigin(value) {
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'left':
+                return HorizontalOrigin.LEFT;
+            case 'right':
+                return HorizontalOrigin.RIGHT;
+            case 'center':
+            default:
+                return HorizontalOrigin.CENTER;
+        }
+    } else if (typeof value === 'number')
+        return value;
+    else
+        throw new DeveloperError('unable parse the ' + value + ' to HorizontalOrigin.');
+};
+
+export default parseHorizontalOrigin;
+export { parseHorizontalOrigin };

package/src/parses/parseLabelStyle.js

@@ -0,0 +1,26 @@
+import { DeveloperError, LabelStyle } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link LabelStyle} 枚举值。
+ * @param {string|number} value 待解析的值，字符串支持 'outline'、'fill_and_outline'、'fill'
+ * @returns {LabelStyle} 解析后的 LabelStyle
+ */
+function parseLabelStyle(value) {
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'outline':
+                return LabelStyle.OUTLINE;
+            case 'fill_and_outline':
+                return LabelStyle.FILL_AND_OUTLINE;
+            case 'fill':
+            default:
+                return LabelStyle.FILL;
+        }
+    } else if (typeof value === 'number')
+        return value;
+    else
+        throw new DeveloperError('unable parse the ' + value + ' to LabelStyle.');
+};
+
+export default parseLabelStyle;
+export { parseLabelStyle };

package/src/parses/parseLatitude.js

@@ -0,0 +1,28 @@
+import parseNumber from '@lijuhong1981/jsmath/src/parseNumber.js';
+import { Check } from "cesium";
+
+/**
+ * 把数字、字符串或数组/对象解析为纬度数值。
+ * @param {number|string|Array|object} value 待解析的值，支持第 1 个分量表示的数组或含 latitude/lat/Lat 字段的对象
+ * @returns {number} 解析后的纬度值
+ */
+function parseLatitude(value) {
+    Check.defined('value', value);
+    if (typeof value === 'number')
+        return value;
+    else if (typeof value === 'string')
+        return parseFloat(value);
+    else if (value[1] !== undefined)
+        return parseNumber(value[1]);
+    else if (value.latitude !== undefined)
+        return parseNumber(value.latitude);
+    else if (value.lat !== undefined)
+        return parseNumber(value.lat);
+    else if (value.Lat !== undefined)
+        return parseNumber(value.Lat);
+    // else if (value.y !== undefined)
+    //     return value.y;
+}
+
+export default parseLatitude;
+export { parseLatitude };

package/src/parses/parseLongitude.js

@@ -0,0 +1,28 @@
+import parseNumber from '@lijuhong1981/jsmath/src/parseNumber.js';
+import { Check } from "cesium";
+
+/**
+ * 把数字、字符串或数组/对象解析为经度数值。
+ * @param {number|string|Array|object} value 待解析的值，支持第 0 个分量表示的数组或含 longitude/lng/Lon 字段的对象
+ * @returns {number} 解析后的经度值
+ */
+function parseLongitude(value) {
+    Check.defined('value', value);
+    if (typeof value === 'number')
+        return value;
+    else if (typeof value === 'string')
+        return parseFloat(value);
+    else if (value[0] !== undefined)
+        return parseNumber(value[0]);
+    else if (value.longitude !== undefined)
+        return parseNumber(value.longitude);
+    else if (value.lng !== undefined)
+        return parseNumber(value.lng);
+    else if (value.Lon !== undefined)
+        return parseNumber(value.Lon);
+    // else if (value.x !== undefined)
+    //     return value.x;
+}
+
+export default parseLongitude;
+export { parseLongitude };

package/src/parses/parsePitch.js

@@ -0,0 +1,26 @@
+/**
+ * 把数字、字符串或数组/对象解析为俯仰角（pitch）数值。
+ * @param {number|string|Array|object} value 待解析的值，支持第 1 个分量表示的数组或含 pitch/y/Pitch 字段的对象
+ * @returns {number} 解析后的俯仰角，无法解析时返回 0
+ */
+function parsePitch(value) {
+    if (value === undefined)
+        return 0;
+    else if (typeof value === 'number')
+        return value;
+    else if (typeof value === 'string')
+        return parseFloat(value);
+    else if (value[1] !== undefined)
+        return value[1];
+    else if (value.pitch !== undefined)
+        return value.pitch;
+    else if (value.y !== undefined)
+        return value.y;
+    else if (value.Pitch !== undefined)
+        return value.Pitch;
+    else
+        return 0;
+};
+
+export default parsePitch;
+export { parsePitch };