deeptwins-engine-3d 0.1.74 → 0.1.75

package/dist/assets/Build/DeepTwins/Workers/CustomRasterClip.worker.js.LICENSE.txt

@@ -0,0 +1,29 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+
+/**
+     * splaytree v3.1.2
+     * Fast Splay tree for Node and browser
+     *
+     * @author Alexander Milevski <info@w8r.name>
+     * @license MIT
+     * @preserve
+     */

package/dist/esm/index.js

@@ -73,11 +73,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.74");
+console.log('DeepTwinsEngine3D Version:', "0.1.75");
 export var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", "0.1.74");
+_defineProperty(DeepTwinsEngine3D, "Version", "0.1.75");
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);

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

@@ -0,0 +1,41 @@
+export type CustomRasterClipBounds = [number, number, number, number];
+export type CustomRasterClipFeature = {
+    feature: any;
+    bbox: CustomRasterClipBounds;
+};
+export type CustomRasterClipResult = {
+    status: 'kept';
+    reason: 'within-clip';
+} | {
+    status: 'discarded';
+    reason: 'outside-clip';
+} | {
+    status: 'clipped';
+    reason: 'intersects-clip';
+    paths: number[][][];
+};
+export type CustomRasterClipTaskOptions = {
+    tileBbox: CustomRasterClipBounds;
+    candidateIndexes: number[];
+    width: number;
+    height: number;
+};
+interface CustomRasterClipWorkerClientOptions {
+    workerUrl?: string;
+    features: CustomRasterClipFeature[];
+}
+declare class CustomRasterClipWorkerClient {
+    private _worker;
+    private _requestId;
+    private _pendingTasks;
+    constructor(options: CustomRasterClipWorkerClientOptions);
+    clip(options: CustomRasterClipTaskOptions): Promise<CustomRasterClipResult>;
+    destroy(): void;
+    private _init;
+    private _handleMessage;
+    private _handleError;
+    private _shutdown;
+    private _failAllPending;
+    private _toError;
+}
+export default CustomRasterClipWorkerClient;

package/dist/esm/tileLayer/CustomRasterClipWorkerClient.js

@@ -0,0 +1,147 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { getDeepTwinsFile } from "../tool/utils";
+var DEFAULT_CUSTOM_RASTER_CLIP_WORKER_FILE = 'Workers/CustomRasterClip.worker.js';
+var DEFAULT_CUSTOM_RASTER_CLIP_WORKER_NAME = 'CustomRasterClip.worker';
+// 创建栅格裁剪 Worker。
+function createClipWorker(options) {
+  var workerUrl = options.workerUrl || getDeepTwinsFile(DEFAULT_CUSTOM_RASTER_CLIP_WORKER_FILE);
+  return new Worker(workerUrl, {
+    type: 'module',
+    name: DEFAULT_CUSTOM_RASTER_CLIP_WORKER_NAME
+  });
+}
+var CustomRasterClipWorkerClient = /*#__PURE__*/function () {
+  function CustomRasterClipWorkerClient(options) {
+    var _this = this;
+    _classCallCheck(this, CustomRasterClipWorkerClient);
+    _defineProperty(this, "_worker", void 0);
+    _defineProperty(this, "_requestId", void 0);
+    _defineProperty(this, "_pendingTasks", void 0);
+    _defineProperty(this, "_handleMessage", function (event) {
+      var response = event.data;
+      var task = _this._pendingTasks.get(response.id);
+      if (!task) {
+        return;
+      }
+      _this._pendingTasks.delete(response.id);
+      if ('error' in response) {
+        task.reject(new Error(response.error));
+        return;
+      }
+      task.resolve(response.result);
+    });
+    _defineProperty(this, "_handleError", function (event) {
+      var _event$error;
+      _this._shutdown(_this._toError((_event$error = event.error) !== null && _event$error !== void 0 ? _event$error : event.message, '栅格裁剪 Worker 运行失败'));
+    });
+    if (typeof Worker !== 'function') {
+      throw new Error('当前环境不支持 Worker');
+    }
+    this._worker = createClipWorker(options);
+    this._requestId = 0;
+    this._pendingTasks = new Map();
+    this._worker.addEventListener('message', this._handleMessage);
+    this._worker.addEventListener('error', this._handleError);
+    this._init(options.features);
+  }
+
+  // 发送单个裁剪任务，Worker 只返回几何关系和画布路径。
+  _createClass(CustomRasterClipWorkerClient, [{
+    key: "clip",
+    value: function clip(options) {
+      var _this2 = this;
+      var worker = this._worker;
+      if (!worker) {
+        return Promise.reject(new Error('栅格裁剪 Worker 已销毁'));
+      }
+      var id = ++this._requestId;
+      return new Promise(function (resolve, reject) {
+        _this2._pendingTasks.set(id, {
+          resolve: resolve,
+          reject: reject
+        });
+        try {
+          worker.postMessage(_objectSpread({
+            type: 'clip',
+            id: id
+          }, options));
+        } catch (error) {
+          _this2._pendingTasks.delete(id);
+          reject(_this2._toError(error, '发送栅格裁剪任务失败'));
+        }
+      });
+    }
+
+    // 销毁 Worker，并让所有挂起任务立即失败。
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._shutdown(new Error('栅格裁剪 Worker 已销毁'));
+    }
+  }, {
+    key: "_init",
+    value: function _init(features) {
+      var worker = this._worker;
+      if (!worker) {
+        return;
+      }
+      try {
+        worker.postMessage({
+          type: 'init',
+          features: features
+        });
+      } catch (error) {
+        var normalizedError = this._toError(error, '初始化栅格裁剪 Worker 失败');
+        this._shutdown(normalizedError);
+        throw normalizedError;
+      }
+    }
+  }, {
+    key: "_shutdown",
+    value: function _shutdown(reason) {
+      if (!this._worker) {
+        this._failAllPending(reason);
+        return;
+      }
+      this._worker.removeEventListener('message', this._handleMessage);
+      this._worker.removeEventListener('error', this._handleError);
+      this._worker.terminate();
+      this._worker = null;
+      this._failAllPending(reason);
+    }
+  }, {
+    key: "_failAllPending",
+    value: function _failAllPending(reason) {
+      var pendingTasks = [];
+      this._pendingTasks.forEach(function (task) {
+        pendingTasks.push(task);
+      });
+      this._pendingTasks.clear();
+      for (var _i = 0, _pendingTasks = pendingTasks; _i < _pendingTasks.length; _i++) {
+        var task = _pendingTasks[_i];
+        task.reject(reason);
+      }
+    }
+  }, {
+    key: "_toError",
+    value: function _toError(error, fallbackMessage) {
+      if (error instanceof Error) {
+        return error;
+      }
+      if (typeof error === 'string' && error.length > 0) {
+        return new Error(error);
+      }
+      return new Error(fallbackMessage);
+    }
+  }]);
+  return CustomRasterClipWorkerClient;
+}();
+export default CustomRasterClipWorkerClient;

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

@@ -50,8 +50,10 @@ import ImageryLayer from './ImageryLayer';
  * - `clipFeatureCrs`：可选，clipFeature 的原始坐标系，默认跟随 dataCrs。
  * - `renderCrs`：可选，bounds、clipFeature 和瓦片范围转换后的目标坐标系，默认 `EPSG:4326`。
  * - `projectionDefs`：可选，自定义 proj4 坐标系定义。
- * - `clipFeature`：可选，GeoJSON Polygon/MultiPolygon/Feature/FeatureCollection。
+ * - `clipFeature`：可选，GeoJSON Polygon/MultiPolygon/Feature/FeatureCollection，`null` 等同未传。
  * - `autoFitBounds`：可选，创建后自动将相机定位到最终范围，需同时传入 `map`。
+ * - `clipWithWorker`：可选，裁剪几何计算优先使用 Worker，默认 `true`。
+ * - `clipWorkerUrl`：可选，自定义裁剪 Worker 地址。
  * - `debug`：可选，`true` 使用 console.log 输出调试信息，函数则接收结构化调试事件。
  */
 /** 通用范围格式：[minX, minY, maxX, maxY]。 */
@@ -139,7 +141,7 @@ export type CustomRasterLayerOptions = {
     renderCrs?: string;
     /** 自定义 proj4 坐标系定义，key 可为 EPSG:xxxx 或其他 proj4 名称。 */
     projectionDefs?: Record<string, string>;
-    /** 用于裁剪瓦片的 GeoJSON 面要素。 */
+    /** 用于裁剪瓦片的 GeoJSON 面要素，null 等同未传。 */
     clipFeature?: any;
     /** 地图实例，autoFitBounds 或手动 fitToBounds 时用于控制相机。 */
     map?: any;
@@ -147,6 +149,10 @@ export type CustomRasterLayerOptions = {
     autoFitBounds?: boolean;
     /** 自动定位到范围时透传给相机 flyTo 的配置，默认 { duration: 0 }。 */
     fitBoundsOptions?: any;
+    /** 是否优先使用 Worker 计算裁剪几何，默认 true，失败时自动回退主线程。 */
+    clipWithWorker?: boolean;
+    /** 自定义裁剪 Worker 地址，优先于默认 DeepTwins 静态资源地址。 */
+    clipWorkerUrl?: string;
     /** 调试开关或自定义调试事件处理函数。 */
     debug?: CustomRasterLayerDebug;
 };
@@ -173,13 +179,20 @@ export default class CustomRasterLayer extends ImageryLayer {
     readonly source: Cesium.UrlTemplateImageryProvider;
     private readonly _debug?;
     private readonly _clipFeatures;
+    private readonly _clipFeatureEntries;
     private readonly _fitBounds?;
+    private readonly _clipWorkerUrl;
+    private _clipWithWorker;
+    private _clipWorkerClient;
     private _mapContext;
+    private _destroyed;
     /** 创建通用栅格图层。 */
     constructor(options: CustomRasterLayerOptions);
     getMap(): any;
     /** 将相机定位到当前图层最终渲染范围。 */
     fitToBounds(map?: any, options?: any): this;
+    /** 销毁图层并释放裁剪 Worker。 */
+    destroy(): void;
     /**
      * Cesium 内部纹理创建钩子。
      *
@@ -191,7 +204,16 @@ export default class CustomRasterLayer extends ImageryLayer {
     _createTexture(context: any, imagery: RasterImagery): any;
     /** 调用 Cesium 原始纹理创建逻辑。 */
     private createTexture;
-    /** 获取当前瓦片与所有裁剪面的交集，用交集路径裁剪当前瓦片。 */
+    /** 根据裁剪面 bbox 粗过滤当前瓦片可能相交的面。 */
+    private getCandidateClipFeatureIndexes;
+    private getClipFeatures;
+    private getClipWorkerClient;
+    private destroyClipWorkerClient;
+    private createClippedTexture;
+    /** 主线程裁剪回退逻辑，保持与 Worker 返回结构一致。 */
+    private clipTileOnMainThread;
+    private applyClipResult;
+    /** 获取当前瓦片与候选裁剪面的交集，用交集路径裁剪当前瓦片。 */
     private getClipIntersections;
     /** 创建与当前瓦片同尺寸的透明 canvas。 */
     private createTileCanvas;