@jorgmoritz/gis-manager 0.1.50 → 0.1.52

package/dist/index.cjs

@@ -13,7 +13,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // package.json
 var package_default = {
   name: "@jorgmoritz/gis-manager",
-  version: "0.1.50"};
+  version: "0.1.52"};
 
 // src/utils/version.ts
 var version = package_default.version;
@@ -342,13 +342,10 @@ var LayerManager = class {
     const minLevel = typeof zr?.min === "number" ? zr.min : void 0;
     const maxLevel = typeof zr?.max === "number" ? zr.max : void 0;
     let bounds = options.rectangle;
-    console.log("[demo] bounds!!", bounds);
-    if (Math.abs(bounds[1]) > 90 && Math.abs(bounds[2]) <= 90) {
+    if (bounds && bounds.length >= 4 && Math.abs(bounds[1]) > 90 && Math.abs(bounds[2]) <= 90) {
       bounds = [bounds[0], bounds[2], bounds[1], bounds[3]];
-      console.warn("[demo] Reordered bounds to [W,S,E,N]:", bounds);
     }
-    const rectDeg = bounds;
-    const rectangle = rectDeg ? C.Rectangle.fromDegrees(rectDeg[0], rectDeg[1], rectDeg[2], rectDeg[3]) : void 0;
+    const rectangle = bounds ? C.Rectangle.fromDegrees(bounds[0], bounds[1], bounds[2], bounds[3]) : void 0;
     switch (options.provider) {
       case "urlTemplate":
         return new C.UrlTemplateImageryProvider({
@@ -358,14 +355,19 @@ var LayerManager = class {
           maximumLevel: maxLevel,
           rectangle
         });
-      case "wmts":
+      case "wmts": {
+        const tilingSchemeType = options.tilingScheme;
+        const tilingScheme = tilingSchemeType === "geographic" ? new C.GeographicTilingScheme() : tilingSchemeType === "webMercator" ? new C.WebMercatorTilingScheme() : void 0;
         return new C.WebMapTileServiceImageryProvider({
           url: options.url,
           layer: options.layer,
           style: options.style ?? "default",
           tileMatrixSetID: options.tileMatrixSetID,
-          format: options.format ?? "image/png"
+          format: options.format ?? "image/png",
+          tilingScheme,
+          maximumLevel: options.maximumLevel
         });
+      }
       case "wms":
         return new C.WebMapServiceImageryProvider({
           url: options.url,
@@ -8527,7 +8529,16 @@ function convertSinoflyWayline(data, options) {
       }
       const lat = parseCoordinate(wp.latitude);
       const lon = parseCoordinate(wp.longitude);
-      const alt = parseCoordinate(wp.altitude);
+      let alt;
+      const ellipsoidHeightValue = wp.ellipsoidHeight;
+      if (ellipsoidHeightValue !== void 0 && ellipsoidHeightValue !== null && ellipsoidHeightValue !== "") {
+        alt = parseCoordinate(ellipsoidHeightValue);
+        if (isNaN(alt)) {
+          alt = parseCoordinate(wp.altitude);
+        }
+      } else {
+        alt = parseCoordinate(wp.altitude);
+      }
       if (isNaN(lat) || isNaN(lon) || isNaN(alt)) {
         throw new Error(`\u822A\u70B9 ${idx} \u5750\u6807\u89E3\u6790\u5931\u8D25: lat=${wp.latitude}, lon=${wp.longitude}, alt=${wp.altitude}`);
       }
@@ -8685,9 +8696,47 @@ function renderFlightPath(CesiumNS, viewer, options) {
   }
   return entity;
 }
-function renderFlightPathPreview(CesiumNS, viewer, options) {
+async function renderFlightPathPreview(CesiumNS, viewer, options) {
   const C = CesiumNS;
-  const entity = renderFlightPath(CesiumNS, viewer, options);
+  const terrainAware = options.terrainAware !== false;
+  const minSafeHeight = options.minSafeHeight ?? 10;
+  let processedOptions = options;
+  if (terrainAware && options.data?.waypointInfo?.length > 0) {
+    try {
+      const waypointPositions = options.data.waypointInfo.map((wp) => {
+        const lon = parseFloat(wp.longitude);
+        const lat = parseFloat(wp.latitude);
+        const alt = parseFloat(wp.altitude);
+        return C.Cartesian3.fromDegrees(lon, lat, alt);
+      });
+      const terrainHeights = await queryTerrainHeights(CesiumNS, viewer, waypointPositions);
+      const adjustedWaypointInfo = options.data.waypointInfo.map((wp, index) => {
+        const originalAlt = parseFloat(wp.altitude);
+        const terrainHeight = terrainHeights[index] ?? 0;
+        const adjustedAlt = originalAlt < terrainHeight ? terrainHeight + minSafeHeight : originalAlt;
+        if (originalAlt < terrainHeight) {
+          console.log(`[renderFlightPathPreview] \u822A\u70B9 ${index} \u9AD8\u5EA6\u8C03\u6574: ${originalAlt.toFixed(1)}m -> ${adjustedAlt.toFixed(1)}m (\u5730\u5F62: ${terrainHeight.toFixed(1)}m)`);
+        }
+        return {
+          ...wp,
+          altitude: String(adjustedAlt)
+        };
+      });
+      processedOptions = {
+        ...options,
+        data: {
+          ...options.data,
+          waypointInfo: adjustedWaypointInfo
+        }
+      };
+    } catch (error) {
+      console.warn("[renderFlightPathPreview] \u5730\u5F62\u9AD8\u5EA6\u67E5\u8BE2\u5931\u8D25\uFF0C\u4F7F\u7528\u539F\u59CB\u9AD8\u5EA6:", error);
+    }
+  }
+  const entity = renderFlightPath(CesiumNS, viewer, processedOptions);
+  if (entity.polyline) {
+    entity.polyline.depthFailMaterial = C.Color.fromCssColorString("#00E676").withAlpha(0.3);
+  }
   const vertexLabelManager = entity._vertexLabelManager;
   let selectedWaypointIndex = options.initialSelectedIndex ?? null;
   const polyline = entity.polyline;
@@ -8704,7 +8753,7 @@ function renderFlightPathPreview(CesiumNS, viewer, options) {
       CesiumNS,
       ...options.adapterOptions
     };
-    const converted = convertSinoflyWayline(options.data, adapterOptions);
+    const converted = convertSinoflyWayline(processedOptions.data, adapterOptions);
     if (converted && converted.waypointData) {
       waypointDataArray = [...converted.waypointData].sort((a, b) => a.index - b.index);
     }
@@ -9143,18 +9192,21 @@ var _CZMLPathManager = class _CZMLPathManager {
    * - 航点点击事件回调
    * - 程序化设置选中航点（高亮显示）
    * - 列表与地图双向联动
+   * - 地形感知：自动调整航点高度，确保航线不会渲染在地形之下
    * 
    * @param options 预览选项
-   * @returns 包含实体和控制器的对象
+   * @returns Promise，包含实体和控制器的对象
    * 
    * @example
    * ```typescript
-   * const { entity, controller } = pathManager.renderFlightPathPreview({
+   * const { entity, controller } = await pathManager.renderFlightPathPreview({
    *   data: sinoflyData,
    *   onWaypointClick: (index, waypoint) => {
    *     console.log('点击了航点', index, waypoint);
    *   },
-   *   initialSelectedIndex: 0
+   *   initialSelectedIndex: 0,
+   *   terrainAware: true,  // 启用地形感知
+   *   minSafeHeight: 10    // 最小安全高度
    * });
    * 
    * // 程序化设置选中航点
@@ -12289,9 +12341,10 @@ var CZMLManager = class {
    * - 航点点击事件回调
    * - 程序化设置选中航点（高亮显示）
    * - 列表与地图双向联动
+   * - 地形感知：自动调整航点高度，确保航线不会渲染在地形之下
    * 
    * @param options 预览选项
-   * @returns 包含实体和控制器的对象
+   * @returns Promise，包含实体和控制器的对象
    */
   renderFlightPathPreview(options) {
     return this.pathMgr.renderFlightPathPreview(options);
@@ -14128,6 +14181,24 @@ var MassPolygonManager = class {
     __publicField(this, "pickThrottleMs", 50);
     // 悬停标签
     __publicField(this, "hoverLabel");
+    // 静态标签（每个多边形的名称标签）
+    __publicField(this, "staticLabelCollection");
+    __publicField(this, "staticLabelsVisible", false);
+    __publicField(this, "staticLabelStyle", {
+      font: "12px sans-serif",
+      fillColor: "#000000",
+      // 黑色字
+      outlineColor: "#ffffff",
+      // 白色描边
+      outlineWidth: 2,
+      showBackground: false,
+      backgroundColor: "rgba(0,0,0,0.5)",
+      backgroundPadding: [4, 2],
+      pixelOffset: [0, 0],
+      scale: 1
+    });
+    // 地形高度缓存（用于 hover 标签等需要快速访问地形高度的场景）
+    __publicField(this, "terrainHeightCache", /* @__PURE__ */ new Map());
     // 销毁标志
     __publicField(this, "isDestroyed", false);
     // ========== 编辑支持方法 ==========
@@ -14223,6 +14294,20 @@ var MassPolygonManager = class {
     this.isClampToGround = options?.clampToGround ?? false;
     const asynchronous = options?.asynchronous ?? true;
     this.polygonHeight = options?.height ?? 0;
+    if (options?.staticLabelStyle) {
+      const labelStyle = options.staticLabelStyle;
+      this.staticLabelStyle = {
+        font: labelStyle.font ?? this.staticLabelStyle.font,
+        fillColor: labelStyle.fillColor ?? this.staticLabelStyle.fillColor,
+        outlineColor: labelStyle.outlineColor ?? this.staticLabelStyle.outlineColor,
+        outlineWidth: labelStyle.outlineWidth ?? this.staticLabelStyle.outlineWidth,
+        showBackground: labelStyle.showBackground ?? this.staticLabelStyle.showBackground,
+        backgroundColor: labelStyle.backgroundColor ?? this.staticLabelStyle.backgroundColor,
+        backgroundPadding: labelStyle.backgroundPadding ?? this.staticLabelStyle.backgroundPadding,
+        pixelOffset: labelStyle.pixelOffset ?? this.staticLabelStyle.pixelOffset,
+        scale: labelStyle.scale ?? this.staticLabelStyle.scale
+      };
+    }
     if (this.isClampToGround && this.viewer.scene.globe) {
       this.viewer.scene.globe.depthTestAgainstTerrain = true;
     }
@@ -14335,8 +14420,10 @@ var MassPolygonManager = class {
         this.layerCollection.add(this.outlinePrimitive);
       }
     }
-    this.labelCollection = new C.LabelCollection();
+    this.labelCollection = new C.LabelCollection({ scene: this.viewer.scene });
     this.layerCollection.add(this.labelCollection);
+    this.staticLabelCollection = new C.LabelCollection({ scene: this.viewer.scene });
+    this.layerCollection.add(this.staticLabelCollection);
     if (this.interactionOptions.enableHover) {
       this.setupHoverHandler();
     }
@@ -14714,7 +14801,7 @@ var MassPolygonManager = class {
     return this.selectedId ?? null;
   }
   /**
-   * 计算多边形中心点
+   * 计算多边形中心点（简单平均）
    */
   calculatePolygonCenter(points) {
     let sumLon = 0, sumLat = 0, sumHeight = 0;
@@ -14729,8 +14816,45 @@ var MassPolygonManager = class {
       height: sumHeight / points.length
     };
   }
+  /**
+   * 计算多边形质心（更准确的中心点算法）
+   * 使用多边形质心公式，对于凹多边形也能得到正确的中心位置
+   */
+  calculatePolygonCentroid(points) {
+    if (points.length < 3) {
+      return this.calculatePolygonCenter(points);
+    }
+    let signedArea = 0;
+    let cx = 0;
+    let cy = 0;
+    let sumHeight = 0;
+    const n = points.length;
+    for (let i = 0; i < n; i++) {
+      const x0 = points[i].lon;
+      const y0 = points[i].lat;
+      const x1 = points[(i + 1) % n].lon;
+      const y1 = points[(i + 1) % n].lat;
+      const a = x0 * y1 - x1 * y0;
+      signedArea += a;
+      cx += (x0 + x1) * a;
+      cy += (y0 + y1) * a;
+      sumHeight += points[i].height ?? 0;
+    }
+    signedArea *= 0.5;
+    if (Math.abs(signedArea) < 1e-10) {
+      return this.calculatePolygonCenter(points);
+    }
+    cx = cx / (6 * signedArea);
+    cy = cy / (6 * signedArea);
+    return {
+      lon: cx,
+      lat: cy,
+      height: sumHeight / n
+    };
+  }
   /**
    * 显示悬停标签
+   * 使用缓存的地形高度（如果可用）来正确放置标签
    */
   showLabel(polygonData) {
     if (!this.interactionOptions.showHoverLabel || !polygonData.name) return;
@@ -14739,7 +14863,24 @@ var MassPolygonManager = class {
     const style = this.interactionOptions.hoverLabelStyle;
     this.hideLabel();
     const center = this.calculatePolygonCenter(polygonData.points);
-    const position = C.Cartesian3.fromDegrees(center.lon, center.lat, this.polygonHeight);
+    let labelHeight;
+    if (this.isClampToGround) {
+      const cachedHeight = this.terrainHeightCache.get(polygonData.id);
+      if (cachedHeight !== void 0) {
+        labelHeight = cachedHeight + 2;
+      } else {
+        const terrainHeight = queryTerrainHeightByLonLatSync(
+          this.CesiumNS,
+          this.viewer,
+          center.lon,
+          center.lat
+        );
+        labelHeight = terrainHeight + 2;
+      }
+    } else {
+      labelHeight = this.polygonHeight;
+    }
+    const position = C.Cartesian3.fromDegrees(center.lon, center.lat, labelHeight);
     this.hoverLabel = this.labelCollection.add({
       position,
       text: polygonData.name,
@@ -14986,6 +15127,178 @@ var MassPolygonManager = class {
       }
     }
   }
+  /**
+   * 获取图层可见性
+   */
+  getVisibility() {
+    return this.layerCollection?.show ?? false;
+  }
+  /**
+   * 隐藏整个图层
+   */
+  hide() {
+    this.setVisibility(false);
+  }
+  /**
+   * 显示整个图层
+   */
+  show() {
+    this.setVisibility(true);
+  }
+  /**
+   * 切换图层可见性
+   * @returns 切换后的可见性状态
+   */
+  toggleVisibility() {
+    const newVisibility = !this.getVisibility();
+    this.setVisibility(newVisibility);
+    return newVisibility;
+  }
+  // ==================== 静态标签管理 ====================
+  /**
+   * 显示所有多边形的静态标签（异步版本）
+   * 在每个多边形的中心点显示其名称
+   * 
+   * 注意：
+   * 1. LabelCollection 不支持 heightReference 属性
+   * 2. 贴地模式下，使用异步方法查询地形高度来正确放置标签
+   * 3. 通过 disableDepthTestDistance 确保标签始终可见
+   * 4. 查询的地形高度会被缓存，供 hover 标签使用
+   */
+  async showStaticLabels() {
+    if (!this.staticLabelCollection) return;
+    const C = this.CesiumNS;
+    this.staticLabelCollection.removeAll();
+    const polygonsWithCenters = [];
+    for (const polygon of this.polygonDataMap.values()) {
+      if (!polygon.name) continue;
+      const center = this.calculatePolygonCentroid(polygon.points);
+      polygonsWithCenters.push({ polygon, center });
+    }
+    if (polygonsWithCenters.length === 0) {
+      this.staticLabelsVisible = true;
+      return;
+    }
+    let labelHeights;
+    if (this.isClampToGround) {
+      const coordinates = polygonsWithCenters.map(({ center }) => ({
+        lon: center.lon,
+        lat: center.lat
+      }));
+      try {
+        const terrainHeights = await queryTerrainHeightsByLonLat(
+          this.CesiumNS,
+          this.viewer,
+          coordinates
+        );
+        labelHeights = terrainHeights.map((h) => h + 2);
+        for (let i = 0; i < polygonsWithCenters.length; i++) {
+          const polygonId = polygonsWithCenters[i].polygon.id;
+          this.terrainHeightCache.set(polygonId, terrainHeights[i]);
+        }
+        console.log(`[MassPolygonManager] \u5F02\u6B65\u67E5\u8BE2\u5730\u5F62\u9AD8\u5EA6\u5B8C\u6210\uFF0C\u8303\u56F4: ${Math.min(...terrainHeights).toFixed(1)}m ~ ${Math.max(...terrainHeights).toFixed(1)}m`);
+      } catch (error) {
+        console.warn("[MassPolygonManager] \u5F02\u6B65\u67E5\u8BE2\u5730\u5F62\u9AD8\u5EA6\u5931\u8D25\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u9AD8\u5EA6:", error);
+        labelHeights = polygonsWithCenters.map(() => 2);
+      }
+    } else {
+      labelHeights = polygonsWithCenters.map(() => this.polygonHeight);
+    }
+    if (this.isDestroyed || !this.staticLabelCollection) {
+      console.warn("[MassPolygonManager] \u5B9E\u4F8B\u5DF2\u9500\u6BC1\uFF0C\u8DF3\u8FC7\u521B\u5EFA\u6807\u7B7E");
+      return;
+    }
+    for (let i = 0; i < polygonsWithCenters.length; i++) {
+      const { polygon, center } = polygonsWithCenters[i];
+      const labelHeight = labelHeights[i];
+      const position = C.Cartesian3.fromDegrees(center.lon, center.lat, labelHeight);
+      this.staticLabelCollection.add({
+        position,
+        text: polygon.name,
+        font: this.staticLabelStyle.font,
+        fillColor: C.Color.fromCssColorString(this.staticLabelStyle.fillColor),
+        outlineColor: C.Color.fromCssColorString(this.staticLabelStyle.outlineColor),
+        outlineWidth: this.staticLabelStyle.outlineWidth,
+        style: C.LabelStyle.FILL_AND_OUTLINE,
+        showBackground: this.staticLabelStyle.showBackground,
+        backgroundColor: C.Color.fromCssColorString(this.staticLabelStyle.backgroundColor),
+        backgroundPadding: new C.Cartesian2(this.staticLabelStyle.backgroundPadding[0], this.staticLabelStyle.backgroundPadding[1]),
+        pixelOffset: new C.Cartesian2(this.staticLabelStyle.pixelOffset[0], this.staticLabelStyle.pixelOffset[1]),
+        scale: this.staticLabelStyle.scale,
+        verticalOrigin: C.VerticalOrigin.CENTER,
+        horizontalOrigin: C.HorizontalOrigin.CENTER,
+        // 禁用深度测试，确保标签始终可见（不会被地形遮挡）
+        disableDepthTestDistance: Number.POSITIVE_INFINITY
+      });
+    }
+    this.staticLabelsVisible = true;
+    this.viewer.scene.requestRender();
+    console.log(`[MassPolygonManager] \u5DF2\u663E\u793A ${this.staticLabelCollection.length} \u4E2A\u9759\u6001\u6807\u7B7E`);
+  }
+  /**
+   * 预加载所有多边形质心的地形高度（用于 hover 标签）
+   * 在贴地模式下，建议在 create() 后调用此方法
+   */
+  async preloadTerrainHeights() {
+    if (!this.isClampToGround) return;
+    const polygons = Array.from(this.polygonDataMap.values());
+    if (polygons.length === 0) return;
+    const coordinates = polygons.map((polygon) => {
+      const center = this.calculatePolygonCentroid(polygon.points);
+      return { lon: center.lon, lat: center.lat };
+    });
+    try {
+      const terrainHeights = await queryTerrainHeightsByLonLat(
+        this.CesiumNS,
+        this.viewer,
+        coordinates
+      );
+      for (let i = 0; i < polygons.length; i++) {
+        this.terrainHeightCache.set(polygons[i].id, terrainHeights[i]);
+      }
+      console.log(`[MassPolygonManager] \u9884\u52A0\u8F7D\u5730\u5F62\u9AD8\u5EA6\u5B8C\u6210: ${polygons.length} \u4E2A\u591A\u8FB9\u5F62`);
+    } catch (error) {
+      console.warn("[MassPolygonManager] \u9884\u52A0\u8F7D\u5730\u5F62\u9AD8\u5EA6\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 隐藏所有多边形的静态标签
+   */
+  hideStaticLabels() {
+    if (!this.staticLabelCollection) return;
+    this.staticLabelCollection.removeAll();
+    this.staticLabelsVisible = false;
+    this.viewer.scene.requestRender();
+    console.log("[MassPolygonManager] \u5DF2\u9690\u85CF\u9759\u6001\u6807\u7B7E");
+  }
+  /**
+   * 切换静态标签显示状态
+   * @returns 切换后的显示状态
+   */
+  async toggleStaticLabels() {
+    if (this.staticLabelsVisible) {
+      this.hideStaticLabels();
+    } else {
+      await this.showStaticLabels();
+    }
+    return this.staticLabelsVisible;
+  }
+  /**
+   * 获取静态标签显示状态
+   */
+  getStaticLabelsVisible() {
+    return this.staticLabelsVisible;
+  }
+  /**
+   * 设置静态标签样式
+   * @param style 样式配置（部分）
+   */
+  async setStaticLabelStyle(style) {
+    this.staticLabelStyle = { ...this.staticLabelStyle, ...style };
+    if (this.staticLabelsVisible) {
+      await this.showStaticLabels();
+    }
+  }
   /**
    * 更新样式（需要重新创建所有多边形）
    */
@@ -15032,7 +15345,10 @@ var MassPolygonManager = class {
     this.outlinePrimitive = void 0;
     this.groundOutlinePrimitive = void 0;
     this.labelCollection = void 0;
+    this.staticLabelCollection = void 0;
+    this.staticLabelsVisible = false;
     this.polygonDataMap.clear();
+    this.terrainHeightCache.clear();
     if (this.viewer?.scene) {
       try {
         this.viewer.scene.requestRender();