deeptwins-engine-3d 0.1.62 → 0.1.64

package/dist/assets/Build/DeepTwins/Workers/MvtVector.worker.js

@@ -0,0 +1 @@
+(()=>{"use strict";const e=Object.fromEntries(Object.entries({Point:1,MultiPoint:2,LineString:3,MultiLineString:4,Polygon:5,MultiPolygon:6}).map(([e,t])=>[t,e])),t=(new TextEncoder,new TextDecoder);class r{constructor(e){this.bytes=function(e){if(e instanceof Uint8Array)return e;if(e instanceof ArrayBuffer)return new Uint8Array(e);if(ArrayBuffer.isView(e))return new Uint8Array(e.buffer,e.byteOffset,e.byteLength);throw new Error("输入不是可解码的二进制数据。")}(e),this.offset=0}isEnd(){return this.offset>=this.bytes.length}readVarint(){let e=0,t=0;for(;;){if(this.offset>=this.bytes.length)throw new Error("读取 protobuf varint 时遇到意外 EOF。");const r=this.bytes[this.offset];if(this.offset+=1,e+=(127&r)*2**t,!(128&r))return e;if(t+=7,t>49)throw new Error("protobuf varint 超出当前实现支持范围。")}}readDouble(){if(this.offset+8>this.bytes.length)throw new Error("读取 protobuf double 时遇到意外 EOF。");const e=new DataView(this.bytes.buffer,this.bytes.byteOffset+this.offset,8).getFloat64(0,!0);return this.offset+=8,e}readBytes(){const e=this.readVarint(),t=this.offset+e;if(t>this.bytes.length)throw new Error("读取 protobuf bytes 时遇到意外 EOF。");const r=this.bytes.slice(this.offset,t);return this.offset=t,r}readString(){return t.decode(this.readBytes())}readTag(){const e=this.readVarint();return{fieldNumber:e>>3,wireType:7&e}}skip(e){switch(e){case 0:return void this.readVarint();case 1:if(this.offset+8>this.bytes.length)throw new Error("跳过 protobuf fixed64 时遇到意外 EOF。");return void(this.offset+=8);case 2:{const e=this.readVarint();if(this.offset+e>this.bytes.length)throw new Error("跳过 protobuf bytes 时遇到意外 EOF。");return void(this.offset+=e)}default:throw new Error(`不支持跳过的 protobuf wire type：${e}`)}}}function s(e){const t=new r(e),s=[];let i;for(;!t.isEnd();){const{fieldNumber:e,wireType:r}=t.readTag();1!==e||1!==r?2!==e||1!==r?3!==e||1!==r?t.skip(r):i=t.readDouble():s[1]=t.readDouble():s[0]=t.readDouble()}if(!Number.isFinite(s[0])||!Number.isFinite(s[1]))throw new Error("解码 Position 失败：缺少合法经纬度。");return void 0===i?s:[s[0],s[1],i]}function i(e){const t=new r(e),i=[];for(;!t.isEnd();){const{fieldNumber:e,wireType:r}=t.readTag();1!==e||2!==r?t.skip(r):i.push(s(t.readBytes()))}return i}function o(e){const t=new r(e),i=[];for(;!t.isEnd();){const{fieldNumber:e,wireType:r}=t.readTag();1!==e||2!==r?t.skip(r):i.push(s(t.readBytes()))}return i}function n(e){const t=new r(e),s=[];for(;!t.isEnd();){const{fieldNumber:e,wireType:r}=t.readTag();1!==e||2!==r?t.skip(r):s.push(o(t.readBytes()))}return s}function a(t){const o=new r(t),a={type:"Feature",id:0,properties:{},geometry:{type:"Point",coordinates:[]}},f=[],u=[],d=[];let y=0,c="{}";for(;!o.isEnd();){const{fieldNumber:e,wireType:t}=o.readTag();1!==e||0!==t?2!==e||0!==t?3!==e||2!==t?4!==e||2!==t?5!==e||2!==t?6!==e||2!==t?o.skip(t):d.push(n(o.readBytes())):u.push(i(o.readBytes())):f.push(s(o.readBytes())):c=o.readString():y=o.readVarint():a.id=o.readVarint()}try{a.properties=JSON.parse(c||"{}")}catch(e){throw new Error(`解码 feature 失败：properties 不是合法 JSON：${e.message}`)}const h=e[y];if(!h)throw new Error(`解码 feature 失败：未知 geometryType=${y}`);switch(h){case"Point":a.geometry={type:"Point",coordinates:f[0]};break;case"MultiPoint":a.geometry={type:"MultiPoint",coordinates:f};break;case"LineString":a.geometry={type:"LineString",coordinates:u[0]||[]};break;case"MultiLineString":a.geometry={type:"MultiLineString",coordinates:u};break;case"Polygon":a.geometry={type:"Polygon",coordinates:d[0]||[]};break;case"MultiPolygon":a.geometry={type:"MultiPolygon",coordinates:d};break;default:throw new Error(`解码 feature 失败：未知几何类型 ${h}`)}return a}function f(e){const t=new r(e),s={version:1,z:0,x:0,y:0,features:[]};for(;!t.isEnd();){const{fieldNumber:e,wireType:r}=t.readTag();1!==e||0!==r?2!==e||0!==r?3!==e||0!==r?4!==e||0!==r?5!==e||2!==r?t.skip(r):s.features.push(a(t.readBytes())):s.y=t.readVarint():s.x=t.readVarint():s.z=t.readVarint():s.version=t.readVarint()}return s}const u=self;u.onmessage=e=>{const{id:t,buffer:r}=e.data;try{u.postMessage({id:t,raw:f(r)})}catch(e){u.postMessage({id:t,error:e instanceof Error&&e.message?e.message:"MVT 解码失败"})}}})();

package/dist/esm/cameraControl/ModelRoamRealTime.js

@@ -235,6 +235,11 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       // 检查是否与上一个位置相同
       var lastPos = this.receivedPositions[this.receivedPositions.length - 1];
       if (this.isSamePosition(newPosition, lastPos)) {
+        // 同位置数据只刷新最后一次采样时间，避免静止时长被并入下一段移动时间
+        if (newPosition.timestamp >= lastPos.timestamp) {
+          lastPos.timestamp = newPosition.timestamp;
+          lastPos.alt = newPosition.alt;
+        }
         return;
       }
 
@@ -269,7 +274,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       var endC3 = Cesium.Cartesian3.fromDegrees(endPos.lng, endPos.lat, endPos.alt);
 
       // 计算飞行时间
-      var flightTime = (endPos.timestamp - startPos.timestamp) / 1000;
+      var flightTime = Math.max(0, (endPos.timestamp - startPos.timestamp) / 1000);
 
       // 计算插值点
       var interpolatedPoints = this._getInterPosition(startC3, endC3, flightTime);

package/dist/esm/drawer/index.d.ts

@@ -18,7 +18,7 @@ export declare const MULTI_POINT_SHAPE_TYPES: {
     readonly POLYLINE: "polyline";
     readonly POLYGON: "polygon";
 };
-export declare const MULTI_POINT_SHAPES: ("polygon" | "polyline")[];
+export declare const MULTI_POINT_SHAPES: ("polyline" | "polygon")[];
 declare class Drawer implements DrawContext {
     private readonly _mapContext;
     private readonly _drawContext;

package/dist/esm/graphicLayer/BaseSource.d.ts

@@ -15,7 +15,7 @@ export default class BaseSource {
     remove(): void;
     setData(data: any): this | undefined;
     _toDestroy(): void;
-    static analysisSourceType(data: any): "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "clampedPolygonGrid" | "other";
+    static analysisSourceType(data: any): "clampedPolygonGrid" | "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "other";
     static wktToGeoJon(wkt: string): any;
     static geoJsonToGeoCartesian3Array(geoJson: any): any[];
     static handleFeaturePoint(feature: any): any;

package/dist/esm/index.d.ts

@@ -75,5 +75,6 @@ export declare class DeepTwinsEngine3D {
     static ViewShedAnalyserLayer: any;
     static VolumeClouds: any;
     static ToolTip: any;
+    static MvtVectorLoad: any;
 }
 export default DeepTwinsEngine3D;

package/dist/esm/index.js

@@ -20,9 +20,9 @@ import DeepTwins from "./deepTwins";
 import Drawer from "./drawer/index";
 import "./global.css";
 import BarrierLayer from "./lowAltitude/BarrierLayer";
+import FactorLayer from "./lowAltitude/FactorLayer";
 import FlightPlanning from "./lowAltitude/FlightPlanning";
 import FlightRiskEvaluation from "./lowAltitude/FlightRiskEvaluation";
-import FactorLayer from "./lowAltitude/FactorLayer";
 import GridDraw from "./lowAltitude/GridDraw";
 import PoiLayer from "./lowAltitude/PoiLayer";
 import VisitLayer from "./lowAltitude/VisitLayer";
@@ -40,6 +40,7 @@ import ImageMaterialAppearance from "./material/primitive/ImageMaterialAppearanc
 import Measure from "./measure";
 import PositionProperty from "./property/PositionProperty";
 import ArcGisLayer from "./tileLayer/ArcGisLayer";
+import MvtVectorLoad from "./tileLayer/MvtVectorLoad";
 import RasterLayer from "./tileLayer/RasterLayer";
 import WmsLayer from "./tileLayer/WmsLayer";
 import WmtsLayer from "./tileLayer/WmtsLayer";
@@ -63,11 +64,11 @@ DEEP_TWINS_BASE_URL && (window.CESIUM_BASE_URL = DEEP_TWINS_BASE_URL);
 // 全局加载css
 loadCss(Cesium.buildModuleUrl('Widgets/widgets.css'));
 // 打印版本信息
-console.log('DeepTwinsEngine3D Version:', "0.1.62");
+console.log('DeepTwinsEngine3D Version:', "0.1.64");
 export var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", "0.1.62");
+_defineProperty(DeepTwinsEngine3D, "Version", "0.1.64");
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);
@@ -142,4 +143,5 @@ _defineProperty(DeepTwinsEngine3D, "BuildClampedPolygonGridUnified", BuildClampe
 _defineProperty(DeepTwinsEngine3D, "ViewShedAnalyserLayer", ViewShedAnalyserLayer);
 _defineProperty(DeepTwinsEngine3D, "VolumeClouds", VolumeClouds);
 _defineProperty(DeepTwinsEngine3D, "ToolTip", ToolTip);
+_defineProperty(DeepTwinsEngine3D, "MvtVectorLoad", MvtVectorLoad);
 export default DeepTwinsEngine3D;

package/dist/esm/plot/utils/Coordinate.d.ts

@@ -36,7 +36,7 @@ declare const transformCartesianToWGS84: (cartesian: any) => {
 declare const transformWGS84ToDMS: (position: {
     x: number;
     y: number;
-    z?: number | undefined;
+    z?: number;
 }) => {
     x: number[];
     y: number[];

package/dist/esm/tileLayer/MvtVectorLoad.d.ts

@@ -0,0 +1,241 @@
+import * as Cesium from 'deeptwins-cesium';
+import { MapContext } from '../map/Map';
+type TileState = 'none' | 'loading' | 'loaded' | 'error';
+interface VectorLoadOptions {
+    url: string;
+    minzoom?: number;
+    maxzoom?: number;
+    maxCacheSize?: number;
+    autoDisplayLayers?: boolean;
+    decodeWithWorker?: boolean;
+    workerUrl?: string;
+}
+type DecodedTileCoordinate = [number, number] | [number, number, number];
+interface DecodedPointGeometry {
+    type: 'Point';
+    coordinates: DecodedTileCoordinate;
+}
+interface DecodedMultiPointGeometry {
+    type: 'MultiPoint';
+    coordinates: DecodedTileCoordinate[];
+}
+interface DecodedLineStringGeometry {
+    type: 'LineString';
+    coordinates: DecodedTileCoordinate[];
+}
+interface DecodedMultiLineStringGeometry {
+    type: 'MultiLineString';
+    coordinates: DecodedTileCoordinate[][];
+}
+interface DecodedPolygonGeometry {
+    type: 'Polygon';
+    coordinates: DecodedTileCoordinate[][];
+}
+interface DecodedMultiPolygonGeometry {
+    type: 'MultiPolygon';
+    coordinates: DecodedTileCoordinate[][][];
+}
+type DecodedTileGeometry = DecodedPointGeometry | DecodedMultiPointGeometry | DecodedLineStringGeometry | DecodedMultiLineStringGeometry | DecodedPolygonGeometry | DecodedMultiPolygonGeometry;
+interface DecodedTileFeature {
+    type: 'Feature';
+    id: number;
+    properties: Record<string, unknown>;
+    geometry: DecodedTileGeometry;
+}
+interface DecodedTile {
+    version: number;
+    z: number;
+    x: number;
+    y: number;
+    features: DecodedTileFeature[];
+}
+interface LoadedTile {
+    x: number;
+    y: number;
+    z: number;
+    raw: DecodedTile;
+}
+interface EvictedTile {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+}
+interface TileDisplayChange {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+    display: 'show' | 'hide';
+}
+interface ManagedTileLayer {
+    show(isShow: boolean): void;
+    remove(): void;
+    isDestroyed?: boolean | (() => boolean);
+}
+type TileLoadLayerResult = ManagedTileLayer | ManagedTileLayer[] | void | null;
+type TileLoadLayerHandlerResult = TileLoadLayerResult | Promise<TileLoadLayerResult>;
+declare const MVT_VECTOR_LOAD_EVENT_TYPES: readonly ["ready", "error", "tileLoad", "tileDisplay", "tileEvict"];
+type MvtVectorLoadEventType = (typeof MVT_VECTOR_LOAD_EVENT_TYPES)[number];
+interface MvtVectorLoadEventHandlerMap {
+    ready(loader: MvtVectorLoad): void;
+    error(error: Error): void;
+    tileLoad(tile: LoadedTile): TileLoadLayerHandlerResult;
+    tileDisplay(change: TileDisplayChange): void;
+    tileEvict(tile: EvictedTile): void;
+}
+interface MvtVectorLoadEventSubscription {
+    off(): void;
+}
+interface TileGeoJSONResult {
+    x: number;
+    y: number;
+    z: number;
+    geoJson: {
+        type: 'FeatureCollection';
+        features: DecodedTileFeature[];
+    };
+}
+interface FrameStateLike {
+    context: {
+        drawingBufferHeight: number;
+    };
+    camera: {
+        frustum: {
+            sseDenominator: number;
+        };
+    };
+    fog: {
+        enabled: boolean;
+        density: number;
+        sse: number;
+    };
+    pixelRatio: number;
+    maximumScreenSpaceError: number;
+    cullingVolume: {
+        computeVisibility: (boundingVolume: unknown) => Cesium.Intersect;
+    };
+}
+interface TileBoundingRegionLike {
+    distanceToCamera(frameState: FrameStateLike): number;
+}
+interface VectorLoadTileOptions {
+    x: number;
+    y: number;
+    z: number;
+    tilingScheme: Cesium.WebMercatorTilingScheme;
+    parent: MvtVectorLoad;
+}
+interface TileVisitor {
+    visitChildren(tile: VectorLoadTile): void;
+    accept(tile: VectorLoadTile): void;
+}
+type ScreenSpaceErrorCalculator = (frameState: FrameStateLike, tile: VectorLoadTile) => number;
+declare class MvtVectorLoad {
+    private readonly _mapContext;
+    url: string;
+    minzoom: number;
+    maximumLevel: number;
+    maxCacheSize: number;
+    ready: boolean;
+    zoom: number;
+    readonly tilingScheme: Cesium.WebMercatorTilingScheme;
+    readonly readyEvent: Cesium.Event<(loader: MvtVectorLoad) => void>;
+    readonly errorEvent: Cesium.Event<(error: Error) => void>;
+    readonly tileLoadEvent: Cesium.Event<(tile: LoadedTile) => TileLoadLayerHandlerResult>;
+    readonly tileDisplayEvent: Cesium.Event<(change: TileDisplayChange) => void>;
+    readonly tileEvictEvent: Cesium.Event<(tile: EvictedTile) => void>;
+    _destroyed: boolean;
+    _initPromise: Promise<MvtVectorLoad> | null;
+    _rootTiles: VectorLoadTile[];
+    _tilesToUpdate: VectorLoadTile[];
+    _loadedTiles: Record<string, LoadedTile>;
+    _pendingTiles: Map<string, Promise<LoadedTile>>;
+    private _cacheOrder;
+    _requestToken: number;
+    private _levelZeroMaximumGeometricError;
+    private _decodeWithWorker;
+    private _autoDisplayLayers;
+    private _workerUrl;
+    private _decodeWorkerClient;
+    private _listenerRegistry;
+    private _displayedTiles;
+    private _managedTileLayers;
+    private _addedToMap;
+    constructor(map: MapContext, options?: Partial<VectorLoadOptions>);
+    getMap(): any;
+    private _addToMap;
+    private _removeFromMap;
+    init(): Promise<MvtVectorLoad>;
+    on<K extends MvtVectorLoadEventType>(type: K, handler: MvtVectorLoadEventHandlerMap[K]): MvtVectorLoadEventSubscription;
+    private _wrapEventHandler;
+    off<K extends MvtVectorLoadEventType>(type: K, handler: MvtVectorLoadEventHandlerMap[K]): void;
+    private _getEventByType;
+    private _createInvalidEventTypeError;
+    private _removeRegisteredListener;
+    private _clearListenerRegistry;
+    private _doInit;
+    private _validateOptions;
+    private _emitError;
+    private _createRootTiles;
+    private _getTileKey;
+    private _touchTileCache;
+    private _pruneLoadedTiles;
+    private _getTilesToUpdate;
+    private _toDisplayedTileState;
+    private _isTileLoaded;
+    private _isSameOrAncestorTile;
+    private _tilesOverlap;
+    private _shouldKeepDisplayedTile;
+    private _shouldDelayTargetTileDisplay;
+    private _raiseTileDisplayChange;
+    private _syncTileDisplayState;
+    private _hideAllDisplayedTiles;
+    private _isManagedTileLayer;
+    private _normalizeManagedTileLayers;
+    private _registerManagedTileLayers;
+    private _isManagedTileLayerDestroyed;
+    private _applyManagedTileLayersDisplay;
+    private _setManagedTileLayersDisplay;
+    private _removeManagedTileLayers;
+    private _removeAllManagedTileLayers;
+    private _getLevelMaximumGeometricError;
+    private _resetTileStatesByKeys;
+    private _getScreenSpaceError;
+    private _buildTileUrl;
+    private _toError;
+    private _getDecodeWorkerClient;
+    private _destroyDecodeWorkerClient;
+    private _decodeTile;
+    private _requestTile;
+    private _loadTile;
+    tileToGeoJSON(tile: LoadedTile): TileGeoJSONResult;
+    update(frameState: FrameStateLike): void;
+    private _updateTiles;
+    private _loadVisibleTile;
+    getLoadedTiles(): LoadedTile[];
+    getTile(x: number, y: number, z: number): LoadedTile | undefined;
+    clearCache(): void;
+    private _resetTileStates;
+    destroy(): void;
+    isDestroyed(): boolean;
+}
+declare class VectorLoadTile {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly key: string;
+    readonly parent: MvtVectorLoad;
+    readonly tilingScheme: Cesium.WebMercatorTilingScheme;
+    readonly rectangle: Cesium.Rectangle;
+    readonly tileBoundingRegion: TileBoundingRegionLike;
+    readonly children: VectorLoadTile[];
+    distanceToCamera: number;
+    visibility: Cesium.Intersect;
+    state: TileState;
+    constructor(options: VectorLoadTileOptions);
+    createChildren(): void;
+    visit(frameState: FrameStateLike, visitor: TileVisitor, getScreenSpaceError: ScreenSpaceErrorCalculator): void;
+}
+export type { EvictedTile, LoadedTile, ManagedTileLayer, MvtVectorLoadEventHandlerMap, MvtVectorLoadEventSubscription, MvtVectorLoadEventType, TileDisplayChange, TileGeoJSONResult, TileLoadLayerHandlerResult, TileLoadLayerResult, };
+export default MvtVectorLoad;