@sl-utils/cesium 1.0.0 → 1.0.1

package/src/types/event.d.ts

@@ -0,0 +1,32 @@
+import type { CameraEventType, ScreenSpaceEventType } from "cesium";
+
+declare global {
+    /**Cesium可注册事件 */
+    /**相机事件 */
+    type CameraEvent = 'CAMERA_MOVESTART' | 'CAMERA_MOVEEND' | 'CAMERA_CHANGED';
+    /**场景事件 */
+    type SceneEvent = 'PREUPDATE' | 'POSTUPDATE' | 'PRERENDER' | 'POSTRENDER';
+    /**时钟事件 */
+    type ClockEvent = 'TICK';
+    /**键盘事件(开发人员编写) */
+    type KeyboardEventDeveloper = 'KEY_DOWN' | 'KEY_UP';
+    /**DOM节点事件(开发人员编写) */
+    type ElementEventDeveloper = 'RESIZE' | KeyboardEventDeveloper | `${keyof typeof ScreenSpaceEventType}`;
+    /**初始化标识 INIT_PICK  */
+    type INIT = 'INIT_PICK'
+    /**整体综合事件 */
+    type UCEvent = ClockEvent | SceneEvent | CameraEvent | ElementEventDeveloper | INIT | 'PICKED' | 'PROGRESS' | 'END';
+    /**键盘按键事件Code */
+    type KeyCode = 'Escape'
+        | 'Backquote' | 'Minus' | 'Equal' | 'Backspace'
+        | 'Tab' | 'Backslash'
+        | 'CapsLock' | 'Semicolon' | 'Quote' | 'Enter'
+        | 'Comma' | 'Period' | 'Slash'
+        | 'MetaLeft' | 'Space' | 'ContextMenu'
+        | `${'Alt' | 'Bracket' | 'Control' | 'Shift'}${'Left' | 'Right'}`
+        | `Key${'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z'}`
+        /**Digit 主键盘上方数字表 Numpad 数字键盘*/
+        | `${'Digit' | 'Numpad' | 'F'}${'0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'}` | 'F10' | 'F11' | 'F12'
+        | `Numpad${'Add' | 'Subtract' | 'Multiply' | 'Divide' | 'Enter' | 'Decimal'}` | 'NumLock'
+        | `Arrow${'Down' | 'Left' | 'Right' | 'Up'}`;
+}

package/src/types/extend.Cesium.d.ts

@@ -0,0 +1,28 @@
+// import { Cartesian3, VoxelShapeType } from "cesium";
+/**对Cesium.d.ts进行扩展 */
+
+declare module 'cesium' {
+    /**cesium中有一个枚举类VoxelShapeType,其实际代码实现了一个方法getMinBounds,通过命名空间实现其合并添加方法 */
+    // enum VoxelShapeType { }      枚举无法添加方法
+    // interface VoxelShapeType { }     枚举声明只能与命名空间或其他枚举声明合并
+    namespace VoxelShapeType {
+        /**获取最小界限 */
+        function getMinBounds(shapeType: VoxelShapeType): Cartesian3
+        /**获取最大界限 */
+        function getMaxBounds(shapeType: VoxelShapeType): Cartesian3
+    }
+    namespace MetadataType {
+        /**获取向量或矩阵类型的组件数量。例如，VEC[N] 返回 [N]，MAT[N] 返回 [N]*[N]。所有其他类型均返回 1*/
+        function getComponentCount(type: MetadataType): number
+    }
+    namespace GeometryInstance {
+
+    }
+    function defaultValue(v1: any, v2: any)
+    var knockout: {
+        track: (value: Object) => void;
+        applyBindings: any
+        getObservable: any
+        subscribe: any
+    };
+}

package/src/types/geometry.d.ts

@@ -0,0 +1,55 @@
+import { ArcType, Cartesian3, EllipseGeometry, Ellipsoid, EllipsoidSurfaceAppearance, PolygonGeometry, PolygonHierarchy, VertexFormat } from "cesium";
+declare global {
+
+
+    /**多边形配置 */
+    interface PolygonGeometryOpt {
+        /**一个可包含孔洞的多边形层次结构 */
+        polygonHierarchy: PolygonHierarchy;
+        /**多边形与椭球面之间的距离 */
+        height?: number;
+        /**多边形挤出面与椭球面之间的距离（单位：米）。 */
+        extrudedHeight?: number;
+        /**要计算的顶点属性。 */
+        vertexFormat?: VertexFormat;
+        /**纹理坐标的旋转角度，单位为弧度。正旋转表示逆时针旋转 */
+        stRotation?: number;
+        /**用作参考的椭球体 */
+        ellipsoid?: Ellipsoid;
+        /**每个纬度和经度之间的距离（以弧度为单位）。决定缓冲区中的位置数量  Math.RADIANS_PER_DEGREE*/
+        granularity?: number;
+        /**为每个位置使用options.positions的高度，而不是使用options.height来确定高度  false*/
+        perPositionHeight?: boolean;
+        /**当为false时，挤出的多边形的顶部保持开放 true*/
+        closeTop?: boolean;
+        /**当为false时，挤出的多边形的底部保持开放 true*/
+        closeBottom?: boolean;
+        /**多边形边必须遵循的线类型。有效选项包括{@link ArcType.GEODESIC}和{@link ArcType.RHUMB}。 */
+        arcType?: ArcType;
+        /**作为由{@link Cartesian2}点组成的{@link PolygonHierarchy}的纹理坐标。对地面图元无影响 */
+        textureCoordinates?: PolygonHierarchy;
+    }
+    /**椭圆几何体配置 */
+    interface EllipseGeometryOpt {
+        /**椭圆的中心点 */
+        center: Cartesian3;
+        /**椭圆半长轴的长度，单位为米 */
+        semiMajorAxis: number;
+        /**椭圆半短轴的长度，单位为米 */
+        semiMinorAxis: number;
+        /**椭圆所在的椭球体 */
+        ellipsoid?: Ellipsoid;
+        /**椭圆与椭球面之间的距离 0.0*/
+        height?: number;
+        /**椭圆挤出面与椭球面之间的距离 0.0*/
+        extrudedHeight?: number;
+        /**从北方向逆时针旋转的角度 0.0*/
+        rotation?: number;
+        /**纹理坐标从北方向逆时针旋转的角度 0.0*/
+        stRotation?: number;
+        /**椭圆上点与点之间的角度距离，以弧度为单位 Math.RADIANS_PER_DEGREE*/
+        granularity?: number;
+        /**要计算的顶点属性 VertexFormat.DEFAULT*/
+        vertexFormat?: VertexFormat;
+    }
+}

package/src/types/plugins.d.ts

@@ -0,0 +1,34 @@
+import { Color } from "cesium";
+
+
+declare global {
+
+    /**插件海拔线配置项 */
+    interface PluginElevationOpt {
+        /**指定高度及其颜色 [高度,[r,g,b,a?],厚度][]*/
+        heightStyles?: [number, [number, number, number, number?], number?][];
+        /**统一透明度 */
+        alpha?: number;
+        /**统一厚度 */
+        thickness?: number,
+        /**是否渐变 */
+        ifGradient?: boolean;
+        /**要划分的网格线(分割线) */
+        grid?: ElevationGrid;
+    }
+    /**海拔线属性网格配置 */
+    interface ElevationGrid {
+        /**网格线条数 */
+        count?: number;
+        /**网格线颜色 [r,g,b,a] */
+        color?: [number, number, number, number?]
+        /**网格线高点高度 */
+        heightAbove?: number;
+        /**网格线低点高度 */
+        heightBelow?: number;
+        /**条纹宽度(米) */
+        width?: number;
+    }
+
+
+}

package/src/types/primitive.d.ts

@@ -0,0 +1,69 @@
+import type { Color, Geometry, GeometryFactory, Matrix4 } from 'cesium';
+import * as Cesium from 'cesium';
+
+declare global {
+    /**区域构造配置 */
+    interface OptPrimitiveArea {
+        /**生成几何实例的id，主要用于事件对象区分 */
+        id?: string;
+        /**类型 圆形 circle | 多边形 polygon */
+        type: 'ellipse' | 'polygon';
+        /**半径 */
+        radius?: number | LnglatHeight,
+        /**颜色 */
+        color?: Color;
+        /**边框颜色 */
+        outlineColor?: Color;
+        /**层级 */
+        zIndex?: number;
+    }
+    /**图元---椭圆区域构造 */
+    interface OptPrimitiveAreaEllipse extends OptPrimitiveArea {
+        /**类型 圆形 circle | 多边形 polygon */
+        type: 'ellipse',
+        /**经纬度坐标 */
+        positions: LnglatHeight,
+        /**半径 */
+        radius: number | LnglatHeight,
+    }
+    /**图元---多边形区域构造 */
+    interface OptPrimitiveAreaPolygon extends OptPrimitiveArea {
+        /**类型 圆形 circle | 多边形 polygon */
+        type: 'polygon',
+        /**经纬度坐标 */
+        positions: LnglatHeight[],
+    }
+
+    /**图元---贴地图片构造 */
+    interface OptPrimitiveImage2D {
+        /**id，设置图元实例的id，用于调取信息 */
+        id?: string;
+        /**图片位置 */
+        image: string;
+        /**经纬度坐标 */
+        positions: LnglatHeight,
+        /**类型 */
+        type?: string,
+        /**固定大小(m) */
+        size?: number;
+        /**旋转 °*/
+        rotation?: number;
+        /**离近是显示的图片*/
+        urlNear?: string;
+        distanceDisplayCondition?: [number, number];
+    }
+
+    /**实例化几何体所需配置 */
+    interface OptInstanceGeometry {
+        id?: any;
+        geometry: Geometry | GeometryFactory;
+        /**几何体大小 */
+        size: number;
+        /**几何体位置 */
+        lnglat: LnglatHeight;
+        /**几何体旋转返现 */
+        rotation: number;
+        modelMatrix?: Matrix4;
+        attributes?: any;
+    }
+}

package/src/types/scene.d.ts

@@ -0,0 +1,25 @@
+import * as Cesium from 'cesium';
+/**针对不同场景需要的特定的类型 */
+declare global {
+    /**实体模型加载配置 */
+    interface EntityModelOpt {
+        /**此物体的唯一id */
+        id: string,
+        /**模型地理位置 */
+        lnglat: LnglatHeight,
+        /**模型转向 */
+        heading?: number;
+        /**模型动画 */
+    }
+
+
+    /**地图着色器配置 */
+    interface LayerShaderOpt {
+        /**对颜色进行百分比调整 */
+        rbga?: any;
+        colorInvert: boolean;
+        colorFilter: any[];
+    }
+
+}
+

package/src/types/viewer.d.ts

@@ -0,0 +1,114 @@
+import type { CesiumTerrainProvider, ClockViewModel, ContextOptions, Credit, DataSourceCollection, Ellipsoid, GeocoderService, Globe, ImageryLayer, MapMode2D, MapProjection, ProviderViewModel, SceneMode, ShadowMode, SkyAtmosphere, SkyBox, Terrain, TerrainProvider, Viewer } from "cesium";
+
+declare global {
+    /**Viewer构造函数的初始化选项 */
+    interface SLCViewerOpt extends Viewer.ConstructorOptions {
+        /**动画表盘[true] */
+        animation?: boolean;
+        /**是否显示时间轴[true] */
+        timeline?: boolean;
+        /**是否显示全屏按钮[true] */
+        fullscreenButton?: boolean;
+        /**是否创建VRButton小部件[false] */
+        vrButton?: boolean;
+        /**是否显示搜索框(搜索地址)[true] */
+        geocoder?: boolean | GeocoderService[];
+        /**是否显示home按钮[true] */
+        homeButton?: boolean;
+        /**是否显示信息框(点击3D模型后显示资源路径或相关信息)[true] */
+        infoBox?: boolean;
+        /**是否显示场景模式选择按钮(2D、3D切换)[true]*/
+        sceneModePicker?: boolean;
+        /**是否显示选中框[true] */
+        selectionIndicator?: boolean;
+        /**是否帮助按钮[true] */
+        navigationHelpButton?: boolean;
+        /**如果导航说明最初应该是可见的，则为true，否则，如果直到用户明确单击按钮才显示，则为false [true] */
+        navigationInstructionsInitiallyVisible?: boolean;
+        /**每个几何实例将仅以3D形式渲染，以节省GPU内存[false] */
+        scene3DOnly?: boolean;
+        /**时钟是否尝试推进模拟时间[false]。此选项优先于设置{@link Viewer#clockViewModel} */
+        shouldAnimate?: boolean;
+        /**用于控制当前时间的时钟视图模型[new ClockViewModel(clock)] */
+        clockViewModel?: ClockViewModel;
+        /**是否显示图层选择按钮[true] */
+        baseLayerPicker?: boolean;
+        /**当前基础图像层的视图模型，如果未提供，则使用第一个可用的基础层。仅在baseLayerPicker=true 时有效 */
+        selectedImageryProviderViewModel?: ProviderViewModel;
+        /**可从BaseLayerPicker选择的ProviderViewModels数组,仅在baseLayerPicker=true时有效[createDefaultImageryProviderViewModels()] */
+        imageryProviderViewModels?: ProviderViewModel[];
+        /**当前基础地形图层的视图模型，如果未提供，则使用第一个可用的基础图层。仅在baseLayerPicker=true时有效 */
+        selectedTerrainProviderViewModel?: ProviderViewModel;
+        /**可从BaseLayerPicker选择的ProviderViewModels数组,仅在baseLayerPicker=true时有效[createDefaultTerrainProviderViewModels()] */
+        terrainProviderViewModels?: ProviderViewModel[];
+        /**应用于地球的最底层图像层。如为false则不添加任何图像提供程序。仅在baseLayerPicker=false时有效[ImageryLayer.fromWorldImagery()] */
+        baseLayer?: ImageryLayer | false;
+        /**要使用的地形提供程序[new EllipsoidTerrainProvider()] */
+        terrainProvider?: TerrainProvider;
+        /**处理异步地形提供程序的地形对象。仅当terrainProvider未定义时才能指定 */
+        terrain?: Terrain;
+        /**用于渲染星星的天空盒。当为undefined时，将使用默认的星星。如果设置为false，则不会添加天空盒、太阳或月亮 */
+        skyBox?: SkyBox | false;
+        /**蓝天，以及地球边缘周围的光晕。设置为 false 可将其关闭 */
+        skyAtmosphere?: SkyAtmosphere | false;
+        /**全屏按钮被按下时，要被置于全屏模式的元素或id [document.body] */
+        fullscreenElement?: Element | string;
+        /**如果此小部件应控制渲染循环，则为true，否则为false [true] */
+        useDefaultRenderLoop?: boolean;
+        /**使用默认渲染循环时的目标帧速率 */
+        targetFrameRate?: number;
+        /**则当出现渲染循环错误时，此小部件将自动向用户显示包含错误的 HTML 面板 [true] */
+        showRenderLoopErrors?: boolean;
+        /**以浏览器的推荐分辨率呈现，并忽略 window.devicePixelRatio [true] */
+        useBrowserRecommendedResolution?: boolean;
+        /**自动跟踪新添加的数据源的时钟设置，如果数据源的时钟发生更改，则进行更新。如果要单独配置时钟，请将其设置为 false [true]*/
+        automaticallyTrackDataSourceClocks?: boolean;
+        /**传递给{@link Scene}的上下文和WebGL创建属性 */
+        contextOptions?: ContextOptions;
+        /**初始场景模式 [SceneMode.SCENE3D] */
+        sceneMode?: SceneMode;
+        /**在二维和哥伦布视图模式下使用的地图投影 [new GeographicProjection()] */
+        mapProjection?: MapProjection;
+        /**场景中使用的地球仪。如果设置为false，则不会添加地球仪，默认情况下天空氛围将被隐藏。 */
+        globe?: Globe | false;
+        /**如果为 true，并且配置支持它，则使用顺序无关半透明 [true] */
+        orderIndependentTranslucency?: boolean;
+        /**将包含{@link CreditDisplay}的DOM元素或ID。 如果未指定，则将学分添加到小部件本身的底部 */
+        creditContainer?: Element | string;
+        /**将包含由{@link CreditDisplay}创建的信用弹出窗口的DOM元素或ID。  如果未指定，它将出现在小部件本身之上 */
+        creditViewport?: Element | string;
+        /**由小部件可视化的数据源集合。如果提供了此参数，假设实例归调用者所有，并且在查看器被销毁时不会被销毁。[new DataSourceCollection()]*/
+        dataSources?: DataSourceCollection;
+        /**确定阴影是否由光源投射 [false] */
+        shadows?: boolean;
+        /**确定地形是否投射或接收来自光源的阴影[ShadowMode.RECEIVE_ONLY] */
+        terrainShadows?: ShadowMode;
+        /**确定2D地图是否可旋转，或者是否可以在水平方向上无限滚动[MapMode2D.INFINITE_SCROLL] */
+        mapMode2D?: MapMode2D;
+        /**是否创建相机模式小部件(正交相机、透视相机)[false] */
+        projectionPicker?: boolean;
+        /**当查看者的画布被点击时，活动元素将模糊。将此设置为 false 对于仅点击画布以检索位置或实体数据而不实际将画布设置为活动元素的情况很有用 [true]*/
+        blurActiveElementOnCanvasFocus?: boolean;
+        /**如果为 true，则仅在场景中的更改确定需要时才呈现帧。启用此选项可降低应用程序的 CPU/GPU 使用率，并减少移动设备的电池使用量，但需要使用{@link Scene#requestRender} 在此模式下显式呈现新帧。在 API 的其他部分对场景进行更改后，在许多情况下都需要这样做。请参阅《通过显式呈现提高性能》[false] */
+        requestRenderMode?: boolean;
+        /**如果 requestRenderMode 为 true，则此值定义了在请求渲染之前允许的最大模拟时间变化。请参阅《通过显式渲染提高性能》（https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/）[0.0] */
+        maximumRenderTimeChange?: number;
+        /**调整 DepthPlane 以解决低于椭球零高度的渲染伪影 [0.0] */
+        depthPlaneEllipsoidOffset?: number;
+        /**如果提供，此值控制多采样抗锯齿的速率。典型的多采样率为每像素 2、4，有时为 8 个采样。更高的 MSAA 采样率可能会影响性能，以换取更好的视觉质量。此值仅适用于支持多采样渲染目标的 WebGL2 上下文 [1] */
+        msaaSamples?: number;
+    }
+    /** 地形静态资源初始化选项 */
+    interface CTerrainAssetOpt extends CesiumTerrainProvider.ConstructorOptions {
+        /**从服务器请求水体效果 */
+        requestWaterMask?: boolean,
+        /**从服务器请求地形光照信息效果 */
+        requestVertexNormals?: boolean,
+        /**从服务器请求每个图块元数据的标记 */
+        requestMetadata?: boolean,
+        /**椭球体。如果未指定，则使用 WGS84 椭球体 */
+        ellipsoid?: Ellipsoid;
+        /**数据源的信用，显示在画布上*/
+        credit?: Credit | string;
+    }
+}

package/src/utils/cesium.ts

@@ -0,0 +1,189 @@
+import * as Cesium from 'cesium';
+import { Cartesian2, Cartesian3, Cartographic, DeveloperError, EllipsoidGeodesic, Scene, Math as CesiumMath, Camera, Property, HeadingPitchRoll, Transforms, Quaternion, Model, Matrix4, Ellipsoid } from 'cesium';
+import { CMath, uc_mathGetPoint } from './common';
+import { uc_tsIfCartesian2, uc_tsIfCartesian3, uc_tsIfLnglatHeight, uc_tsIfProperty, uc_tsIfScene } from './types';
+/**获取指定经纬度处转向的四元数时使用 uc_getQuaternion */
+const HEADING_PITCH_ROLL: HeadingPitchRoll = new HeadingPitchRoll(0, 0, 0)
+/**作为中转的C3 */
+const CARTESIAN3_CONST = new Cartesian3();
+const ELLIPSOIDGEODESIC_CONST = new EllipsoidGeodesic();
+/**根据经纬度和高度获取地球Cartesian3的坐标 */
+function getCartesian3ByLnglat(lnglatheight: LnglatHeight, ellipsoid?: Cesium.Ellipsoid, result?: Cesium.Cartesian3, ifTerrain?: boolean) {
+    const [lng, lat, height = 0] = lnglatheight;
+    return Cartesian3.fromDegrees(lng, lat, height, ellipsoid, result);
+}
+/**获取三维坐标根据屏幕坐标（如果超出地球re） 
+ * @param scene 场景
+ * @param c2 屏幕坐标
+ * @param result 如果超出地球会返回undefined，但是result不变
+ * @param ifTerrain 是否有地形
+*/
+function getCartesian3ByCartesian2(c2: Cartesian2, scene: Scene, result?: Cartesian3, ifTerrain?: boolean): Cartesian3 | undefined {
+    result = scene.pickPosition(c2, result);
+    if (!result) return;
+    if (!ifTerrain) {
+        /**有地形数据时不要将高度降为0 */
+        let { longitude, latitude } = Cartographic.fromCartesian(result);
+        getCartesian3ByLnglat([CesiumMath.toDegrees(longitude), CesiumMath.toDegrees(latitude), 0], undefined, result)
+    }
+    return result;
+}
+/**获取地球上的经纬度和高度坐标(单位：度，非弧度值) 
+ * @param p  三维笛卡尔坐标 | 屏幕坐标 | 经纬度地理坐标 
+ * @param result 结果要覆盖的原对象(相对new能节约性能)
+ * @param scene 场景(屏幕坐标必须传)
+ * @param ifTerrain 是否拥有地形
+*/
+function uc_getLnglat(p: Cartesian3 | LnglatHeight, result?: LnglatHeight): LnglatHeight;
+function uc_getLnglat(p: Cartesian2, scene: Scene, result?: LnglatHeight, ifTerrain?: boolean): LnglatHeight | undefined;
+function uc_getLnglat(p1: Cartesian3 | Cartesian2 | LnglatHeight, p2?: Scene | LnglatHeight, p3?: LnglatHeight, p4?: boolean): LnglatHeight | undefined {
+    let flag, res: LnglatHeight = (uc_tsIfScene(p2) ? p3 : p2) || [0, 0];
+    if (uc_tsIfCartesian3(p1)) {
+        flag = uc_getCartesian3(p1, CARTESIAN3_CONST);
+    } else if (uc_tsIfCartesian2(p1)) {
+        if (!p2 || uc_tsIfLnglatHeight(p2)) throw new DeveloperError(`屏幕坐标参数2必须传入场景`);
+        flag = uc_getCartesian3(p1, p2, CARTESIAN3_CONST, p4);
+    } else if (uc_tsIfLnglatHeight(p1)) {
+        flag = uc_getCartesian3(p1, CARTESIAN3_CONST)
+    }
+    if (!flag) return undefined;
+    let cartesian = Cartographic.fromCartesian(CARTESIAN3_CONST);
+    if (!cartesian) return undefined;
+    res[0] = uc_mathGetPoint(CesiumMath.toDegrees(cartesian.longitude), 8),
+        res[1] = uc_mathGetPoint(CesiumMath.toDegrees(cartesian.latitude), 8),
+        res[2] = uc_mathGetPoint(cartesian.height);
+    return res
+}
+/**获取二维屏幕坐标 
+ * @param p1  三维笛卡尔坐标 | 屏幕坐标 | 经纬度地理坐标 
+ * @param result 结果要覆盖的原对象(相对new能节约性能)
+ * @param scene 场景(三维、经纬度必须传)
+ * @param ifTerrain 是否拥有地形
+*/
+function uc_getCartesian2(p: Cartesian2, result?: Cartesian2): Cartesian2;
+function uc_getCartesian2(p: Cartesian3 | LnglatHeight, scene: Scene, result?: Cartesian2): Cartesian2 | undefined;
+function uc_getCartesian2(p1: Cartesian3 | Cartesian2 | LnglatHeight, p2?: Scene | Cartesian2, p3?: Cartesian2): Cartesian2 {
+    if (uc_tsIfCartesian3(p1) || uc_tsIfLnglatHeight(p1)) {
+        if (!p2 || uc_tsIfCartesian2(p2)) throw new DeveloperError(`参数2(场景)必须传入`);
+        uc_getCartesian3(p1, CARTESIAN3_CONST)
+        return p2.cartesianToCanvasCoordinates(CARTESIAN3_CONST, p3);
+    }
+    return p1.clone(p2 as Cartesian2)
+}
+/**获取地球上的Cartesian3坐标 
+ * @param p  三维笛卡尔坐标 | 屏幕坐标 | 经纬度地理坐标 
+ * @param result 结果要覆盖的原对象(相对new能节约性能)
+ * @param scene 场景(屏幕坐标必须传)
+ * @param ifTerrain 是否拥有地形
+*/
+function uc_getCartesian3(p: Cartesian3 | LnglatHeight, result?: Cartesian3): Cartesian3;
+function uc_getCartesian3(p: Cartesian2, scene: Scene, result?: Cartesian3, ifTerrain?: boolean): Cartesian3 | undefined;
+function uc_getCartesian3(p1: Cartesian3 | Cartesian2 | LnglatHeight, p2?: Scene | Cartesian3, p3?: Cartesian3, p4?: boolean): Cartesian3 | undefined {
+    if (uc_tsIfLnglatHeight(p1)) {
+        return getCartesian3ByLnglat(p1, undefined, p2 as Cartesian3)
+    } else if (uc_tsIfCartesian3(p1)) {
+        return p1.clone(p2 as Cartesian3)
+    } else if (uc_tsIfCartesian2(p1)) {
+        if (!p2 || uc_tsIfCartesian3(p2)) throw new DeveloperError(`屏幕坐标参数2必须传入场景`);
+        return getCartesian3ByCartesian2(p1, p2, p3, p4)
+    }
+}
+
+
+/**获取模型的世界坐标 */
+function uc_getCartesian3ByModel(target: Model, result: Cartesian3 = new Cartesian3()): Cartesian3 {
+    return Matrix4.multiplyByPoint(target.modelMatrix, Cartesian3.ZERO, result)
+}
+
+/**计算得到P2相对P1的方位
+ * (heading => 正北 0 东 80 南 180 西 -90(270)  pitch 正上方 +90 正下方 -90 )
+ *  */
+function uc_getDirection(p1: Cartesian3 | LnglatHeight, p2: Cartesian3 | LnglatHeight) {
+    const [lng1, lat1, height1] = uc_getLnglat(p1), [lng2, lat2, height2] = uc_getLnglat(p2);
+    const c1 = Cartographic.fromDegrees(lng1, lat1, 0), c2 = Cartographic.fromDegrees(lng2, lat2, 0)
+    // 使用 EllipsoidGeodesic 计算大圆距离
+    ELLIPSOIDGEODESIC_CONST.setEndPoints(c1, c2);
+    return {
+        heading: Math.PI / 2 - Math.atan2(lat2 - lat1, lng2 - lng1),
+        pitch: Math.atan2(height2 - height1, ELLIPSOIDGEODESIC_CONST.surfaceDistance),
+        roll: 0.0
+    }
+}
+
+/**获取经纬度差值根据指定距离（纬度上的差值是固定的，经度方向的差值是根据纬度决定的）
+ * @param {number} lat 纬度
+ * @param {number} distance 距离
+ * @returns {经度差值diffLng , 纬度差值diffLat } 经纬度差值
+ */
+function uc_getDiffDegreesByDistance(lat: number, distance: number) {
+    // 计算distance米在指定纬度上的偏移量
+    const diffLng = distance / (111320 * Math.cos(CMath.toRadians(lat))); // 经度方向10米的偏移量
+    const diffLat = distance / 111320; // 纬度方向10米的偏移量
+    Ellipsoid.UNIT_SPHERE
+    return { diffLng, diffLat };
+}
+/**获取指定纬度点上固定差值的距离
+ *  @param {number} lat 纬度
+ *  @param {number} distance 距离
+ */
+function uc_getDistanceByLatOffset(lat: number, offset: number): number {
+    return 111320 * offset * Math.cos(CMath.toRadians(lat));
+}
+/**获取地球两点间的距离(m)小数点若干*/
+function uc_getDistanceByCartesian3(c0: Cartesian3, c1: Cartesian3): number {
+    const cartographic1 = Cartographic.fromCartesian(c0);
+    const cartographic2 = Cartographic.fromCartesian(c1);
+    // 使用 EllipsoidGeodesic 计算大圆距离
+    ELLIPSOIDGEODESIC_CONST.setEndPoints(cartographic1, cartographic2);
+    const distance = ELLIPSOIDGEODESIC_CONST.surfaceDistance; // 距离以米为单位
+    return distance;
+}
+/**获取地球两点间的距离(曲面)和距离单位*/
+function uc_getDistanceAndUnits(c0: Cartesian3, c1: Cartesian3): { distance, units } {
+    let distance = uc_getDistanceByCartesian3(c0, c1), units = 'm';
+    if (distance < 1) {
+        distance = uc_mathGetPoint(distance * 100);
+        units = 'cm'
+    } else if (distance < 1000) {
+        distance = uc_mathGetPoint(distance)
+    } else {
+        distance = uc_mathGetPoint(distance / 1000)
+        units = 'km'
+    }
+    return { distance, units };
+}
+
+
+/**获取指定经纬度处转向的四元数 
+ * @param lnglat 物体所处的位置
+ * @param rotate 物体要旋转的度数
+*/
+function uc_getQuaternion(position: LnglatHeight | Cartesian3, rotate: number): Quaternion {
+    if (uc_tsIfLnglatHeight(position)) position = uc_getCartesian3(position)
+    const heading = CMath.toRadians(rotate);
+    const pitch = CMath.toRadians(0);
+    const roll = CMath.toRadians(0);
+    HEADING_PITCH_ROLL.heading = heading;
+    HEADING_PITCH_ROLL.pitch = pitch;
+    HEADING_PITCH_ROLL.roll = roll;
+    const orientation = Transforms.headingPitchRollQuaternion(
+        position,
+        HEADING_PITCH_ROLL
+    );
+    return orientation
+}
+
+
+
+export {
+    uc_getLnglat,
+    uc_getCartesian2,
+    uc_getCartesian3,
+    uc_getCartesian3ByModel,
+    uc_getDistanceByCartesian3,
+    uc_getDistanceByLatOffset,
+    uc_getDistanceAndUnits,
+    uc_getDirection,
+    uc_getDiffDegreesByDistance,
+    uc_getQuaternion,
+};

package/src/utils/common.ts

@@ -0,0 +1,87 @@
+/**一些简单的数学工具 */
+import { Math as Cmath } from 'cesium'
+const CMath = Cmath;
+/**深拷贝将 obj 的数据更新到res => 更新或深拷贝
+ * @param obj 获取更新数据的对象
+ * @param res 存储更新结果的对象
+ * @param update 只更新原结果res的数据,不删减
+ * @example 
+ * let obj = { a:{a1:1},b:1},res = {a:{a2:2},c:2};
+ * assign( obj , res) =>  { a: { a1:1, a2:2}, b:1, c:2}
+ * assign( obj , res, false)=> { a: { a1:1}, b:1}
+*/
+function uc_deepAssign<T>(obj: T, res?: any, update: boolean = true): T {
+    if (Array.isArray(obj)) {
+        res = res && Array.isArray(res) && update ? res : [];
+        obj.map((e, i) => res[i] = uc_deepAssign(e, res[i]))
+    } else if (typeof obj === 'object') {
+        res = res && update ? res : Object.create(null);
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                const e = obj[key];
+                if (Array.isArray(e) || typeof e === 'object') {
+                    res[key] = uc_deepAssign(e, res[key], update)
+                } else {
+                    res[key] = e
+                }
+            }
+        }
+    } else if (obj === undefined && update) {
+        res = res
+    } else {
+        res = obj
+    }
+    return res
+}
+
+/**数组删除或增加指定(不改变引用地址，不适用于多重数组)
+ * @param arr 要增删的数组
+ * @param item 要添加或删除的项目组
+ * @param add true--添加
+*/
+function uc_arrChange<T>(arr: T[], item: T | T[], add: boolean = true): T[] {
+    if (!Array.isArray(item)) item = [item];
+    if (add) {
+        item.forEach(e => {
+            if (!arr.includes(e)) arr.push(e);
+        });
+    } else {
+        item.forEach(e => {
+            const index = arr.indexOf(e);
+            if (index > -1) arr.splice(index, 1);
+        });
+    }
+    return arr;
+}
+/**获取指定位数的小数(num过大或point过大可能导致数据异常出现负值) 
+ * @param num 数字
+ * @param point 需要几位小数
+ * @param type 0四舍五入 1下取整  2 上取整 
+*/
+function uc_mathGetPoint(num: number, point: number = 2, type: 0 | 1 | 2 = 0): number {
+    let res = num * Math.pow(10, point);
+    res = type == 0 ? Math.round(res) : type == 1 ? Math.floor(res) : Math.ceil(res);
+    return res / Math.pow(10, point)
+}
+
+/**获得一个uuid */
+function uc_getUUID() {
+    let d = Date.now();
+    if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+        d += performance.now(); // use high-precision timer if available
+    }
+    const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (d + Math.random() * 16) % 16 | 0;
+        d = Math.floor(d / 16);
+        return (c == 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+    return uuid;
+}
+
+export {
+    CMath,
+    uc_mathGetPoint,
+    uc_getUUID,
+    uc_deepAssign,
+    uc_arrChange,
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+
+export * from './cesium';
+export * from './common';
+export * from './map';
+export * from './types';