@lijuhong1981/cesium.utils 0.0.0-stage → 0.1.1

package/src/parses/parseRoll.js

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

package/src/parses/parseRotationToHeadingPitchRoll.js

@@ -0,0 +1,40 @@
+import getValidValue from "@lijuhong1981/jscheck/src/getValidValue.js";
+import { defined, HeadingPitchRoll, Matrix3, Quaternion } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseEulerToHeadingPitchRoll from "./parseEulerToHeadingPitchRoll.js";
+
+/**
+ * 把多种旋转表示解析为 {@link HeadingPitchRoll} 对象。
+ * @param {HeadingPitchRoll|Quaternion|Matrix3|Array|object} value 待解析的旋转值，支持 HeadingPitchRoll、四元数、旋转矩阵、欧拉角数组或对象
+ * @param {HeadingPitchRoll} [result] 用于存储结果的可选对象
+ * @param {boolean} [isDegrees] 输入是否为角度制，为 true 时按角度解析
+ * @returns {HeadingPitchRoll} 解析后的 HeadingPitchRoll
+ */
+function parseRotationToHeadingPitchRoll(value, result, isDegrees) {
+    if (value instanceof HeadingPitchRoll) {
+        if (result && value !== result)
+            return HeadingPitchRoll.clone(value, result);
+        else
+            return value;
+    } else if (value instanceof Quaternion)
+        return HeadingPitchRoll.fromQuaternion(value, result);
+    else if (value instanceof Matrix3) {
+        value = Quaternion.fromRotationMatrix(value, Scratch.scratchQuaternion);
+        return HeadingPitchRoll.fromQuaternion(value, result);
+    } else if (defined(value.heading) || defined(value.yaw)) {
+        if (isDegrees)
+            return HeadingPitchRoll.fromDegrees(getValidValue(value.heading, value.yaw), value.pitch, value.roll, result);
+        else
+            return HeadingPitchRoll.fromRadians(getValidValue(value.heading, value.yaw), value.pitch, value.roll, result);
+    } else if (Array.isArray(value)) {
+        if (isDegrees)
+            return HeadingPitchRoll.fromDegrees(value[0], value[1], value[2], result);
+        else
+            return HeadingPitchRoll.fromRadians(value[0], value[1], value[2], result);
+    } else {
+        return parseEulerToHeadingPitchRoll(value, result, isDegrees);
+    }
+};
+
+export default parseRotationToHeadingPitchRoll;
+export { parseRotationToHeadingPitchRoll };

package/src/parses/parseRotationToMatrix3.js

@@ -0,0 +1,25 @@
+import { Matrix3 } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseRotationToHeadingPitchRoll from "./parseRotationToHeadingPitchRoll.js";
+
+/**
+ * 把多种旋转表示解析为 3x3 旋转矩阵（{@link Matrix3}）。
+ * @param {Matrix3|HeadingPitchRoll|Quaternion|Array|object} value 待解析的旋转值
+ * @param {Matrix3} [result] 用于存储结果的可选对象
+ * @param {boolean} [isDegrees] 输入是否为角度制，为 true 时按角度解析
+ * @returns {Matrix3} 解析后的旋转矩阵
+ */
+function parseRotationToMatrix3(value, result, isDegrees) {
+    if (value instanceof Matrix3) {
+        if (result && value !== result)
+            return Matrix3.clone(value, result);
+        else
+            return value;
+    } else {
+        const hpr = parseRotationToHeadingPitchRoll(value, Scratch.scratchHeadingPitchRoll, isDegrees);
+        return Matrix3.fromHeadingPitchRoll(hpr, result);
+    }
+};
+
+export default parseRotationToMatrix3;
+export { parseRotationToMatrix3 };

package/src/parses/parseRotationToQuaternion.js

@@ -0,0 +1,27 @@
+import { defined, Quaternion } from "cesium";
+import Scratch from "../utils/Scratch.js";
+import parseRotationToHeadingPitchRoll from "./parseRotationToHeadingPitchRoll.js";
+
+/**
+ * 把多种旋转表示解析为四元数（{@link Quaternion}）。
+ * @param {Quaternion|HeadingPitchRoll|Matrix3|Array|object} value 待解析的旋转值，未定义时返回单位四元数
+ * @param {Quaternion} [result] 用于存储结果的可选对象
+ * @param {boolean} [isDegrees] 输入是否为角度制，为 true 时按角度解析
+ * @returns {Quaternion} 解析后的四元数
+ */
+function parseRotationToQuaternion(value, result, isDegrees) {
+    if (!defined(value))
+        return Quaternion.IDENTITY.clone(result);
+    else if (value instanceof Quaternion) {
+        if (result && value !== result)
+            return Quaternion.clone(value, result);
+        else
+            return value;
+    } else {
+        const hpr = parseRotationToHeadingPitchRoll(value, Scratch.scratchHeadingPitchRoll, isDegrees);
+        return Quaternion.fromHeadingPitchRoll(hpr, result);
+    }
+};
+
+export default parseRotationToQuaternion;
+export { parseRotationToQuaternion };

package/src/parses/parseShadowMode.js

@@ -0,0 +1,26 @@
+import { ShadowMode } from "cesium";
+
+/**
+ * 把字符串或数字解析为 Cesium 的 {@link ShadowMode} 枚举值。
+ * @param {string|number} value 待解析的值，字符串包含 'cast' 返回 CAST_ONLY、'receive' 返回 RECEIVE_ONLY、'enable' 返回 ENABLED
+ * @returns {ShadowMode} 解析后的 ShadowMode
+ */
+function parseShadowMode(value) {
+    if (typeof value === 'string') {
+        value = value.toLowerCase();
+        if (value.match('cast'))
+            return ShadowMode.CAST_ONLY;
+        else if (value.match('receive'))
+            return ShadowMode.RECEIVE_ONLY;
+        else if (value.match('enable'))
+            return ShadowMode.ENABLED;
+        else
+            return ShadowMode.DISABLED;
+    } else if (typeof value === 'number')
+        return value;
+    else
+        return ShadowMode.DISABLED;
+};
+
+export default parseShadowMode;
+export { parseShadowMode };

package/src/parses/parseToBoundingRectangle.js

@@ -0,0 +1,33 @@
+import { BoundingRectangle, DeveloperError } from "cesium";
+
+/**
+ * 把数组或对象解析为包围矩形（{@link BoundingRectangle}）。
+ * @param {BoundingRectangle|Array|object} value 待解析的值
+ * @param {BoundingRectangle} [result] 用于存储结果的可选对象
+ * @returns {BoundingRectangle} 解析后的包围矩形
+ */
+function parseToBoundingRectangle(value, result) {
+    if (value instanceof BoundingRectangle) {
+        if (result && value !== result) {
+            BoundingRectangle.clone(value, result);
+            return result;
+        } else
+            return value;
+    }
+
+    if (result === undefined)
+        result = new BoundingRectangle();
+
+    if (Array.isArray(value)) {
+        BoundingRectangle.unpack(value, 0, result);
+    } else if (typeof value === 'object') {
+        BoundingRectangle.clone(value, result);
+    } else {
+        throw new DeveloperError('can not parse the ' + value + ' to BoundingRectangle.');
+    }
+
+    return result;
+};
+
+export default parseToBoundingRectangle;
+export { parseToBoundingRectangle };

package/src/parses/parseToCartesian2.js

@@ -0,0 +1,35 @@
+import getValidValue from '@lijuhong1981/jscheck/src/getValidValue.js';
+import parseNumber from '@lijuhong1981/jsmath/src/parseNumber.js';
+import { Cartesian2, Check, defined, DeveloperError } from "cesium";
+
+/**
+ * 把数字、字符串或数组/对象解析为二维笛卡尔坐标（{@link Cartesian2}）。
+ * @param {Cartesian2|number|string|Array|object} value 待解析的值，支持 [x,y] 数组或含 x/y 字段的对象
+ * @param {Cartesian2} [result] 用于存储结果的可选对象
+ * @param {number} [defaultValue=0.0] 缺省分量的默认值
+ * @returns {Cartesian2} 解析后的二维笛卡尔坐标
+ */
+function parseToCartesian2(value, result, defaultValue = 0.0) {
+    if (!defined(value)) {
+        if (typeof defaultValue === 'number')
+            return Cartesian2.fromElements(defaultValue, defaultValue, result);
+        else
+            throw new DeveloperError('value undefined.');
+    } else if (value instanceof Cartesian2) {
+        if (result && value !== result)
+            return value.clone(result);
+        else
+            return value;
+    } else if (typeof value === 'number' || typeof value === 'string') {
+        value = parseNumber(value);
+        return Cartesian2.fromElements(value, value, result);
+    }
+    const x = getValidValue(value[0], value.x, defaultValue);
+    Check.typeOf.number('x', x);
+    const y = getValidValue(value[1], value.y, defaultValue);
+    Check.typeOf.number('y', y);
+    return Cartesian2.fromElements(x, y, result);
+};
+
+export default parseToCartesian2;
+export { parseToCartesian2 };

package/src/parses/parseToCartesian3.js

@@ -0,0 +1,37 @@
+import getValidValue from '@lijuhong1981/jscheck/src/getValidValue.js';
+import parseNumber from '@lijuhong1981/jsmath/src/parseNumber.js';
+import { Cartesian3, Check, defined, DeveloperError } from "cesium";
+
+/**
+ * 把数字、字符串或数组/对象解析为三维笛卡尔坐标（{@link Cartesian3}）。
+ * @param {Cartesian3|number|string|Array|object} value 待解析的值，支持 [x,y,z] 数组或含 x/y/z 字段的对象
+ * @param {Cartesian3} [result] 用于存储结果的可选对象
+ * @param {number} [defaultValue=0.0] 缺省分量的默认值
+ * @returns {Cartesian3} 解析后的三维笛卡尔坐标
+ */
+function parseToCartesian3(value, result, defaultValue = 0.0) {
+    if (!defined(value)) {
+        if (typeof defaultValue === 'number')
+            return Cartesian3.fromElements(defaultValue, defaultValue, defaultValue, result);
+        else
+            throw new DeveloperError('value undefined.');
+    } else if (value instanceof Cartesian3) {
+        if (result && value !== result)
+            return value.clone(result);
+        else
+            return value;
+    } else if (typeof value === 'number' || typeof value === 'string') {
+        value = parseNumber(value);
+        return Cartesian3.fromElements(value, value, value, result);
+    }
+    const x = getValidValue(value[0], value.x, defaultValue);
+    Check.typeOf.number('x', x);
+    const y = getValidValue(value[1], value.y, defaultValue);
+    Check.typeOf.number('y', y);
+    const z = getValidValue(value[2], value.z, defaultValue);
+    Check.typeOf.number('z', z);
+    return Cartesian3.fromElements(x, y, z, result);
+};
+
+export default parseToCartesian3;
+export { parseToCartesian3 };

package/src/parses/parseToCartesian3Array.js

@@ -0,0 +1,21 @@
+import { Check } from "cesium";
+import parseToCartesian3 from "./parseToCartesian3.js";
+
+/**
+ * 把数组批量解析为三维笛卡尔坐标数组（{@link Cartesian3}）。
+ * @param {Array} array 待解析的数组
+ * @param {Array} [result=[]] 用于存储结果的数组
+ * @param {number} [defaultValue] 缺省分量的默认值
+ * @returns {Array} 解析后的三维笛卡尔坐标数组
+ */
+function parseToCartesian3Array(array, result = [], defaultValue) {
+    Check.typeOf.array('array', array);
+
+    for (let i = 0; i < array.length; i++) {
+        result[i] = parseToCartesian3(array[i], result[i], defaultValue);
+    }
+    return result;
+};
+
+export default parseToCartesian3Array;
+export { parseToCartesian3Array };

package/src/parses/parseToCartesian4.js

@@ -0,0 +1,39 @@
+import getValidValue from '@lijuhong1981/jscheck/src/getValidValue.js';
+import parseNumber from '@lijuhong1981/jsmath/src/parseNumber.js';
+import { Cartesian4, Check, defined, DeveloperError } from "cesium";
+
+/**
+ * 把数字、字符串或数组/对象解析为四维笛卡尔坐标（{@link Cartesian4}）。
+ * @param {Cartesian4|number|string|Array|object} value 待解析的值，支持 [x,y,z,w] 数组或含 x/y/z/w 字段的对象
+ * @param {Cartesian4} [result] 用于存储结果的可选对象
+ * @param {number} [defaultValue=0.0] 缺省分量的默认值
+ * @returns {Cartesian4} 解析后的四维笛卡尔坐标
+ */
+function parseToCartesian4(value, result, defaultValue = 0.0) {
+    if (!defined(value)) {
+        if (typeof defaultValue === 'number')
+            return Cartesian4.fromElements(defaultValue, defaultValue, defaultValue, defaultValue, result);
+        else
+            throw new DeveloperError('value undefined.');
+    } else if (value instanceof Cartesian4) {
+        if (result && value !== result)
+            return value.clone(result);
+        else
+            return value;
+    } else if (typeof value === 'number' || typeof value === 'string') {
+        value = parseNumber(value);
+        return Cartesian4.fromElements(value, value, value, value, result);
+    }
+    const x = getValidValue(value[0], value.x, defaultValue);
+    Check.typeOf.number('x', x);
+    const y = getValidValue(value[1], value.y, defaultValue);
+    Check.typeOf.number('y', y);
+    const z = getValidValue(value[2], value.z, defaultValue);
+    Check.typeOf.number('z', z);
+    const w = getValidValue(value[3], value.w, defaultValue);
+    Check.typeOf.number('w', w);
+    return Cartesian4.fromElements(x, y, z, w, result);
+};
+
+export default parseToCartesian4;
+export { parseToCartesian4 };

package/src/parses/parseToCartographic.js

@@ -0,0 +1,31 @@
+import { Cartesian3, Cartographic } from "cesium";
+import Geographic from "../additions/Geographic.js";
+import { parseHeight } from "./parseAltitude.js";
+import parseLatitude from "./parseLatitude.js";
+import parseLongitude from "./parseLongitude.js";
+
+/**
+ * 把地理坐标解析为 {@link Cartographic} 对象，输入按经度/纬度角度制处理。
+ * @param {Cartographic|Geographic|Cartesian3|Array|object} value 待解析的值
+ * @param {Cartographic} [result] 用于存储结果的可选对象
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Cartographic} 解析后的 Cartographic
+ */
+function parseToCartographic(value, result, ellipsoid) {
+    if (value instanceof Cartographic) {
+        if (result && value !== result)
+            return value.clone(result);
+        else
+            return value;
+    } else if (value instanceof Geographic)
+        return value.toCartographic(result);
+    else if (value instanceof Cartesian3)
+        return value.toCartographic(ellipsoid, result);
+    const longitude = parseLongitude(value);
+    const latitude = parseLatitude(value);
+    const height = parseHeight(value);
+    return Cartographic.fromDegrees(longitude, latitude, height, result);
+};
+
+export default parseToCartographic;
+export { parseToCartographic };

package/src/parses/parseToColor.js

@@ -0,0 +1,33 @@
+import { Cartesian3, Cartesian4, Check, Color, DeveloperError } from "cesium";
+
+/**
+ * 把字符串、数字、笛卡尔坐标或数组解析为颜色（{@link Color}）。
+ * @param {Color|string|number|Cartesian3|Cartesian4|Array} value 待解析的值，字符串按 CSS 颜色、数字按 RGBA 解析
+ * @param {Color} [result] 用于存储结果的可选对象
+ * @returns {Color} 解析后的颜色
+ */
+function parseToColor(value, result) {
+    Check.defined('value', value);
+    if (value instanceof Color) {
+        if (result && value !== result)
+            return value.clone(result);
+        else
+            return value;
+    } else if (typeof value === 'string') {
+        return Color.fromCssColorString(value, result);
+    } else if (typeof value === 'number') {
+        return Color.fromRgba(value, result);
+    } else if (value instanceof Cartesian3) {
+        return Color.fromCartesian3(value, result);
+    } else if (value instanceof Cartesian4) {
+        return Color.fromCartesian4(value, result);
+    } else if (Array.isArray(value)) {
+        return Color.unpack(value, 0, result);
+    } else {
+        console.error('unsupported color value:', value);
+        throw new DeveloperError('unsupported color value:' + value);
+    }
+};
+
+export default parseToColor;
+export { parseToColor };

package/src/parses/parseToDistanceDisplayCondition.js

@@ -0,0 +1,41 @@
+import { DeveloperError, DistanceDisplayCondition } from "cesium";
+
+/**
+ * 把数组、对象、数字或字符串解析为 {@link DistanceDisplayCondition} 对象。
+ * @param {DistanceDisplayCondition|Array|object|number|string} value 待解析的值，数字/字符串时以 near=0、该值为 far 处理
+ * @param {DistanceDisplayCondition} [result] 用于存储结果的可选对象
+ * @returns {DistanceDisplayCondition} 解析后的距离显示条件
+ */
+function parseToDistanceDisplayCondition(value, result) {
+    if (!value) return;
+
+    if (value instanceof DistanceDisplayCondition) {
+        if (result && value !== result) {
+            DistanceDisplayCondition.clone(value, result);
+            return result;
+        } else
+            return value;
+    }
+
+    if (result === undefined)
+        result = new DistanceDisplayCondition();
+
+    if (Array.isArray(value)) {
+        DistanceDisplayCondition.unpack(value, 0, result);
+    } else if (typeof value === 'object') {
+        DistanceDisplayCondition.clone(value, result);
+    } else if (typeof value === 'number') {
+        result.near = 0;
+        result.far = value;
+    } else if (typeof value === 'string') {
+        result.near = 0;
+        result.far = parseFloat(value);
+    } else {
+        throw new DeveloperError('can not parse the ' + value + ' to DistanceDisplayCondition.');
+    }
+
+    return result;
+};
+
+export default parseToDistanceDisplayCondition;
+export { parseToDistanceDisplayCondition };

package/src/parses/parseToGeographic.js

@@ -0,0 +1,31 @@
+import { Cartesian3, Cartographic } from "cesium";
+import Geographic from "../additions/Geographic.js";
+import parseAltitude from "./parseAltitude.js";
+import parseLatitude from "./parseLatitude.js";
+import parseLongitude from "./parseLongitude.js";
+
+/**
+ * 把地理坐标解析为 {@link Geographic} 对象，输入按角度制处理。
+ * @param {Geographic|Cartographic|Cartesian3|Array|object} value 待解析的值
+ * @param {Geographic} [result] 用于存储结果的可选对象
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Geographic} 解析后的 Geographic
+ */
+function parseToGeographic(value, result, ellipsoid) {
+    if (value instanceof Geographic) {
+        if (result && value !== result)
+            return value.clone(result);
+        else
+            return value;
+    } else if (value instanceof Cartographic)
+        return value.toGeographic(result);
+    else if (value instanceof Cartesian3)
+        return value.toGeographic(ellipsoid, result);
+    const longitude = parseLongitude(value);
+    const latitude = parseLatitude(value);
+    const altitude = parseAltitude(value);
+    return Geographic.fromDegrees(longitude, latitude, altitude, result);
+};
+
+export default parseToGeographic;
+export { parseToGeographic };

package/src/parses/parseToHeadingPitchRange.js

@@ -0,0 +1,45 @@
+import { Math as CesiumMath, Check, HeadingPitchRange } from "cesium";
+
+/**
+ * 把数组或对象解析为 {@link HeadingPitchRange} 对象。
+ * @param {HeadingPitchRange|Array|object} value 待解析的值，支持 [heading,pitch,range] 数组或含 heading/pitch/range 字段的对象
+ * @param {HeadingPitchRange} [result=new HeadingPitchRange()] 用于存储结果的可选对象
+ * @param {boolean} [isDegrees=true] 输入是否为角度制，为 true 时按角度解析
+ * @returns {HeadingPitchRange} 解析后的 HeadingPitchRange
+ */
+function parseToHeadingPitchRange(value, result = new HeadingPitchRange(), isDegrees = true) {
+    Check.defined('value', value);
+
+    if (value instanceof HeadingPitchRange) {
+        if (value !== result) {
+            HeadingPitchRange.clone(value, result);
+            return result;
+        } else
+            return value;
+    }
+
+    if (Array.isArray(value)) {
+        if (isDegrees) {
+            result.heading = CesiumMath.toRadians(value[0]);
+            result.pitch = CesiumMath.toRadians(value[1]);
+        } else {
+            result.heading = value[0];
+            result.pitch = value[1];
+        }
+        result.range = value[2];
+    } else if (typeof value === 'object') {
+        if (isDegrees) {
+            result.heading = CesiumMath.toRadians(value.heading ?? value.yaw);
+            result.pitch = CesiumMath.toRadians(value.pitch);
+        } else {
+            result.heading = value.heading ?? value.yaw;
+            result.pitch = value.pitch;
+        }
+        result.range = value.range;
+    }
+
+    return result;
+};
+
+export default parseToHeadingPitchRange;
+export { parseToHeadingPitchRange };

package/src/parses/parseToJulianDate.js

@@ -0,0 +1,23 @@
+import { JulianDate } from "cesium";
+
+/**
+ * 把日期字符串、数字时间戳、Date 或 {@link JulianDate} 解析为儒略日期。
+ * @param {JulianDate|string|number|Date} value 待解析的值
+ * @param {JulianDate} [result] 用于存储结果的可选对象
+ * @returns {JulianDate} 解析后的儒略日期
+ */
+function parseToJulianDate(value, result) {
+    if (value instanceof JulianDate) {
+        if (result && value !== result)
+            return JulianDate.clone(value, result);
+        else
+            return value;
+    } else if (typeof value === 'string' || typeof value === 'number') {
+        return JulianDate.fromDate(new Date(value), result);
+    } else if (value instanceof Date) {
+        return JulianDate.fromDate(value, result);
+    }
+};
+
+export default parseToJulianDate;
+export { parseToJulianDate };

package/src/parses/parseToNearFarScalar.js

@@ -0,0 +1,33 @@
+import { DeveloperError, NearFarScalar } from "cesium";
+
+/**
+ * 把数组或对象解析为 {@link NearFarScalar} 对象。
+ * @param {NearFarScalar|Array|object} value 待解析的值
+ * @param {NearFarScalar} [result] 用于存储结果的可选对象
+ * @returns {NearFarScalar} 解析后的 NearFarScalar
+ */
+function parseToNearFarScalar(value, result) {
+    if (value instanceof NearFarScalar) {
+        if (result && value !== result) {
+            NearFarScalar.clone(value, result);
+            return result;
+        } else
+            return value;
+    }
+
+    if (result === undefined)
+        result = new NearFarScalar();
+
+    if (Array.isArray(value)) {
+        NearFarScalar.unpack(value, 0, result);
+    } else if (typeof value === 'object') {
+        NearFarScalar.clone(value, result);
+    } else {
+        throw new DeveloperError('can not parse the ' + value + ' to NearFarScalar.');
+    }
+
+    return result;
+};
+
+export default parseToNearFarScalar;
+export { parseToNearFarScalar };

package/src/parses/parseToPlane.js

@@ -0,0 +1,37 @@
+import getValidValue from "@lijuhong1981/jscheck/src/getValidValue.js";
+import { Cartesian3, Cartesian4, Check, defined, Plane } from "cesium";
+import Scratch from "../utils/Scratch.js";
+
+/**
+ * 把对象或数组解析为平面（{@link Plane}）。
+ * @param {Plane|Array|object} value 待解析的值，支持 [x,y,z,w] 数组、含 point/normal 或 normal/distance 字段的对象
+ * @param {Plane} [result] 用于存储结果的可选对象
+ * @returns {Plane} 解析后的平面
+ */
+function parseToPlane(value, result) {
+    Check.defined('value', value);
+    if (value instanceof Plane) {
+        if (result && value !== result)
+            return Plane.clone(value, result);
+        else
+            return value;
+    } else if (defined(value.point) && defined(value.normal)) {
+        return Plane.fromPointNormal(value.point, value.normal, result);
+    } else if (defined(value.normal) && defined(value.distance)) {
+        if (!result)
+            result = new Plane();
+        Cartesian3.clone(value.normal, result.normal);
+        result.distance = value.distance;
+        return result;
+    }
+
+    const x = getValidValue(value[0], value.x);
+    const y = getValidValue(value[1], value.y);
+    const z = getValidValue(value[2], value.z);
+    const w = getValidValue(value[3], value.w);
+    const coefficients = Cartesian4.fromElements(x, y, z, w, Scratch.scratchCartesian4);
+    return Plane.fromCartesian4(coefficients, result);
+};
+
+export default parseToPlane;
+export { parseToPlane };

package/src/parses/parseToPolygonHierarchy.js

@@ -0,0 +1,48 @@
+import { Cartesian3, defined, DeveloperError, PolygonHierarchy } from "cesium";
+
+/**
+ * 把洞信息解析为 {@link PolygonHierarchy} 数组。
+ * @param {PolygonHierarchy|Array|object} holes 待解析的洞信息
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {Array} 解析后的 PolygonHierarchy 数组
+ */
+function parseHoles(holes, ellipsoid) {
+    if (holes instanceof PolygonHierarchy)
+        return [holes];
+    else if (Array.isArray(holes)) {
+        if (holes[0] instanceof Cartesian3 || defined(holes[0].x))
+            return [parseToPolygonHierarchy(holes, undefined, ellipsoid)];
+        else if (holes[0] instanceof PolygonHierarchy)
+            return holes;
+        const result = [];
+        for (let i = 0; i < holes.length; i++) {
+            const hierarchy = parseToPolygonHierarchy(holes[i].positions, holes[i].holes, ellipsoid);
+            result.push(hierarchy);
+        }
+        return result;
+    } else if (typeof holes === 'object') {
+        const result = [];
+        const hierarchy = parseToPolygonHierarchy(holes.positions, holes.holes, ellipsoid);
+        result.push(hierarchy);
+        return result;
+    } else {
+        throw new DeveloperError('unsupported holes: ' + holes);
+    }
+};
+
+/**
+ * 把顶点坐标与洞信息解析为多边形层级（{@link PolygonHierarchy}）。
+ * @param {Array} positions 多边形顶点坐标
+ * @param {PolygonHierarchy|Array|object} [holes] 洞信息
+ * @param {Ellipsoid} [ellipsoid] 参考椭球体
+ * @returns {PolygonHierarchy} 解析后的多边形层级
+ */
+function parseToPolygonHierarchy(positions, holes, ellipsoid) {
+    if (defined(holes)) {
+        holes = parseHoles(holes, ellipsoid);
+    }
+    return new PolygonHierarchy(positions, holes);
+};
+
+export default parseToPolygonHierarchy;
+export { parseHoles, parseToPolygonHierarchy };