my-openlayer 2.4.12 → 2.5.1

package/core/point/PointPulseLayer.js

@@ -0,0 +1,207 @@
+import Feature from "ol/Feature";
+import { Point as OlPoint } from "ol/geom";
+import VectorLayer from "ol/layer/Vector";
+import VectorSource from "ol/source/Vector";
+import { Circle as CircleStyle, Fill, Icon, Stroke, Style, Text } from "ol/style";
+import ProjectionUtils from "../../utils/ProjectionUtils";
+import ValidationUtils from "../../utils/ValidationUtils";
+import { ConfigManager } from "../map";
+/**
+ * 高性能闪烁点图层构建器。
+ */
+export default class PointPulseLayer {
+    static createTextStyle(options, text) {
+        const defaultTextOptions = ConfigManager.DEFAULT_POINT_TEXT_OPTIONS;
+        return new Text({
+            text,
+            font: options.textFont || defaultTextOptions.textFont,
+            fill: new Fill({ color: options.textFillColor || defaultTextOptions.textFillColor }),
+            stroke: new Stroke({
+                color: options.textStrokeColor || defaultTextOptions.textStrokeColor,
+                width: options.textStrokeWidth || defaultTextOptions.textStrokeWidth
+            }),
+            offsetY: options.textOffsetY || defaultTextOptions.textOffsetY
+        });
+    }
+    static withOpacity(color, opacity) {
+        const safeOpacity = Math.max(0, Math.min(1, opacity));
+        const rgbaMatch = color.match(/^rgba?\(([^)]+)\)$/i);
+        if (rgbaMatch) {
+            const parts = rgbaMatch[1].split(',').map(part => part.trim());
+            if (parts.length >= 3) {
+                const alpha = parts.length >= 4 ? Number(parts[3]) : 1;
+                const nextAlpha = Number.isFinite(alpha) ? alpha * safeOpacity : safeOpacity;
+                return `rgba(${parts[0]}, ${parts[1]}, ${parts[2]}, ${nextAlpha})`;
+            }
+        }
+        if (/^#[0-9a-f]{6}$/i.test(color)) {
+            const red = parseInt(color.slice(1, 3), 16);
+            const green = parseInt(color.slice(3, 5), 16);
+            const blue = parseInt(color.slice(5, 7), 16);
+            return `rgba(${red}, ${green}, ${blue}, ${safeOpacity})`;
+        }
+        return color;
+    }
+    static createFeatures(pointData, options) {
+        const pointFeatureList = [];
+        pointData.forEach(item => {
+            if (!ValidationUtils.validateCoordinates(item)) {
+                return;
+            }
+            pointFeatureList.push(new Feature({
+                rawData: item,
+                type: options.layerName,
+                layerName: options.layerName,
+                geometry: new OlPoint(ProjectionUtils.transformCoordinate([item.lgtd, item.lttd], options))
+            }));
+        });
+        return pointFeatureList;
+    }
+    static create(map, pointData, options) {
+        const pulseOptions = {
+            enabled: options.pulse?.enabled ?? true,
+            duration: options.pulse?.duration ?? 2400,
+            radius: options.pulse?.radius ?? [8, 26],
+            colorMap: options.pulse?.colorMap ?? {
+                0: 'rgba(255, 48, 54, 0.45)',
+                1: 'rgba(255, 136, 0, 0.45)',
+                2: 'rgba(253, 216, 46, 0.38)',
+                3: 'rgba(6, 183, 253, 0.3)'
+            },
+            strokeColorMap: options.pulse?.strokeColorMap,
+            strokeWidth: options.pulse?.strokeWidth ?? 0,
+            frameCount: Math.max(1, options.pulse?.frameCount ?? 24)
+        };
+        const levelKey = options.levelKey ?? 'lev';
+        const pulseStyleCache = new globalThis.Map();
+        const staticStyleCache = new globalThis.Map();
+        let frameIndex = 0;
+        let renderedFrameIndex = -1;
+        let rafId = null;
+        let running = false;
+        const source = new VectorSource({
+            features: PointPulseLayer.createFeatures(pointData, options)
+        });
+        const createStyles = (feature) => {
+            const rawData = feature.get('rawData');
+            const level = rawData?.[levelKey] ?? 'default';
+            const progress = frameIndex / Math.max(1, pulseOptions.frameCount - 1);
+            const [minRadius, maxRadius] = pulseOptions.radius;
+            const radius = minRadius + (maxRadius - minRadius) * progress;
+            const opacity = 1 - progress;
+            const fillColor = pulseOptions.colorMap[level] ?? pulseOptions.colorMap.default ?? 'rgba(6, 183, 253, 0.32)';
+            const strokeColor = pulseOptions.strokeColorMap?.[level] ?? pulseOptions.strokeColorMap?.default;
+            const styles = [];
+            if (pulseOptions.enabled) {
+                const pulseCacheKey = `${level}_${frameIndex}`;
+                let pulseStyle = pulseStyleCache.get(pulseCacheKey);
+                if (!pulseStyle) {
+                    pulseStyle = new Style({
+                        zIndex: 0,
+                        image: new CircleStyle({
+                            radius,
+                            fill: new Fill({ color: PointPulseLayer.withOpacity(fillColor, opacity) }),
+                            stroke: strokeColor && pulseOptions.strokeWidth > 0
+                                ? new Stroke({ color: PointPulseLayer.withOpacity(strokeColor, opacity), width: pulseOptions.strokeWidth })
+                                : undefined
+                        })
+                    });
+                    pulseStyleCache.set(pulseCacheKey, pulseStyle);
+                }
+                styles.push(pulseStyle);
+            }
+            const text = options.textVisible && options.textKey && rawData ? rawData[options.textKey] ?? '' : '';
+            const staticCacheKey = [
+                options.img ?? options.icon?.src ?? '',
+                options.scale ?? options.icon?.scale ?? ConfigManager.DEFAULT_POINT_ICON_SCALE,
+                options.iconColor ?? options.icon?.color ?? '',
+                text
+            ].join('|');
+            let pointStyle = staticStyleCache.get(staticCacheKey);
+            if (pointStyle) {
+                styles.push(pointStyle);
+                return styles;
+            }
+            const pointStyleOptions = {};
+            const iconSrc = options.img ?? options.icon?.src;
+            if (iconSrc) {
+                pointStyleOptions.image = new Icon({
+                    src: iconSrc,
+                    scale: options.scale ?? options.icon?.scale ?? ConfigManager.DEFAULT_POINT_ICON_SCALE,
+                    color: options.iconColor ?? options.icon?.color
+                });
+            }
+            else if (options.icon) {
+                pointStyleOptions.image = new CircleStyle({
+                    radius: options.icon.radius ?? 5,
+                    fill: new Fill({ color: options.icon.fillColor ?? '#06b7fd' }),
+                    stroke: new Stroke({
+                        color: options.icon.strokeColor ?? '#ffffff',
+                        width: options.icon.strokeWidth ?? 2
+                    })
+                });
+            }
+            if (text) {
+                pointStyleOptions.text = PointPulseLayer.createTextStyle(options, text);
+            }
+            if (pointStyleOptions.image || pointStyleOptions.text) {
+                pointStyle = new Style(pointStyleOptions);
+                pointStyle.setZIndex(1);
+                staticStyleCache.set(staticCacheKey, pointStyle);
+                styles.push(pointStyle);
+            }
+            return styles;
+        };
+        const layer = new VectorLayer({
+            layerName: options.layerName,
+            source,
+            style: createStyles,
+            zIndex: options.zIndex || ConfigManager.DEFAULT_POINT_OPTIONS.zIndex,
+        });
+        layer.setVisible(options.visible === undefined ? true : options.visible);
+        map.addLayer(layer);
+        const tick = () => {
+            if (!running)
+                return;
+            const duration = Math.max(1, pulseOptions.duration);
+            const now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+            const nextFrameIndex = Math.floor(((now % duration) / duration) * pulseOptions.frameCount);
+            if (nextFrameIndex !== renderedFrameIndex) {
+                frameIndex = nextFrameIndex;
+                renderedFrameIndex = nextFrameIndex;
+                layer.changed();
+            }
+            rafId = requestAnimationFrame(tick);
+        };
+        const stop = () => {
+            running = false;
+            if (rafId !== null) {
+                cancelAnimationFrame(rafId);
+                rafId = null;
+            }
+        };
+        const start = () => {
+            if (running || !pulseOptions.enabled)
+                return;
+            running = true;
+            tick();
+        };
+        start();
+        return {
+            layer,
+            source,
+            start,
+            stop,
+            setVisible: (visible) => layer.setVisible(visible),
+            updateData: (nextData) => {
+                source.clear();
+                source.addFeatures(PointPulseLayer.createFeatures(nextData, options));
+            },
+            remove: () => {
+                stop();
+                source.clear();
+                map.removeLayer(layer);
+            }
+        };
+    }
+}

package/core/point/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Point } from './Point';
+export { default as PointPulseLayer } from './PointPulseLayer';
+export { default as PointClusterLayer } from './PointClusterLayer';
+export { default as PointOverlay } from './PointOverlay';

package/core/point/index.js

@@ -0,0 +1,4 @@
+export { default as Point } from './Point';
+export { default as PointPulseLayer } from './PointPulseLayer';
+export { default as PointClusterLayer } from './PointClusterLayer';
+export { default as PointOverlay } from './PointOverlay';

package/core/{Polygon.d.ts → polygon/Polygon.d.ts}

@@ -1,10 +1,9 @@
 import Map from "ol/Map";
 import VectorLayer from "ol/layer/Vector";
 import VectorSource from "ol/source/Vector";
-import { Image as ImageLayer, Heatmap } from "ol/layer";
-import { Geometry } from "ol/geom";
+import { Image as ImageLayer } from "ol/layer";
 import Feature from "ol/Feature";
-import { PolygonOptions, MapJSONData, PointData, HeatMapOptions, ImageLayerData, MaskLayerOptions, FeatureColorUpdateOptions } from '../types';
+import { PolygonOptions, MapJSONData, PointData, HeatMapOptions, ImageLayerData, MaskLayerOptions, FeatureColorUpdateOptions } from '../../types';
 /**
  * Polygon 类用于处理地图上的面要素操作
  * 包括添加多边形、边框、图片图层、热力图等功能
@@ -49,19 +48,6 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addPolygonByUrl(url: string, options?: PolygonOptions): VectorLayer<VectorSource>;
-    /**
-     * 创建样式或样式函数
-     * @param options 配置选项
-     * @returns 样式或样式函数
-     */
-    private createStyle;
-    /**
-     * 获取要素文本
-     * @param feature 要素对象
-     * @param options 配置选项
-     * @returns 文本内容
-     */
-    private getFeatureText;
     /**
      * 适应图层视图
      * @param layer 图层对象
@@ -77,13 +63,6 @@ export default class Polygon {
     updateFeatureColor(layerName: string, colorObj?: {
         [propName: string]: string;
     }, options?: FeatureColorUpdateOptions): void;
-    /**
-     * 更新单个要素的颜色
-     * @param feature 要素对象
-     * @param colorObj 颜色映射对象
-     * @param options 配置选项
-     */
-    private updateSingleFeatureColor;
     /**
      * 设置外围蒙版图层
      *
@@ -99,7 +78,7 @@ export default class Polygon {
         strokeWidth?: number;
         strokeColor?: string;
         zIndex?: number;
-    }): VectorLayer<VectorSource<Feature<Geometry>>, Feature<Geometry>>;
+    }): VectorLayer<VectorSource<Feature<import("ol/geom").Geometry>>, Feature<import("ol/geom").Geometry>>;
     /**
      * 添加图片图层
      * @param imageData 图片数据，包含url和extent
@@ -108,37 +87,12 @@ export default class Polygon {
      * @throws 当数据格式无效时抛出错误
      */
     addImageLayer(imageData: ImageLayerData, options?: PolygonOptions): ImageLayer<any>;
-    /**
-     * 尝试更新现有图层
-     * @private
-     */
-    private tryUpdateExistingImageLayer;
-    /**
-     * 创建新的图像图层
-     * @private
-     */
-    private createNewImageLayer;
-    /**
-     * 更新图层属性
-     * @private
-     */
-    private updateImageLayerProperties;
-    /**
-     * 配置图层基本属性
-     * @private
-     */
-    private configureImageLayer;
-    /**
-     * 添加图层到地图并应用裁剪
-     * @private
-     */
-    private addImageLayerToMap;
     /**
      * 添加热力图图层
      * @param pointData 点数据数组
      * @param options 热力图配置
      */
-    addHeatmap(pointData: PointData[], options?: HeatMapOptions): Heatmap<Feature<Geometry>, VectorSource<Feature<Geometry>>>;
+    addHeatmap(pointData: PointData[], options?: HeatMapOptions): import("ol/layer").Heatmap<Feature<import("ol/geom").Geometry>, VectorSource<Feature<import("ol/geom").Geometry>>>;
     /**
      * 添加遮罩图层
      * @param data GeoJSON格式的遮罩数据

package/core/polygon/Polygon.js

@@ -0,0 +1,248 @@
+"use strict";
+import VectorLayer from "ol/layer/Vector";
+import VectorSource from "ol/source/Vector";
+import GeoJSON from "ol/format/GeoJSON";
+import { ErrorHandler } from '../../utils/ErrorHandler';
+import ProjectionUtils from '../../utils/ProjectionUtils';
+import ValidationUtils from '../../utils/ValidationUtils';
+import { ConfigManager, MapTools } from "../map";
+import PolygonHeatmapLayer from './PolygonHeatmapLayer';
+import PolygonImageLayer from './PolygonImageLayer';
+import PolygonMaskLayer from './PolygonMaskLayer';
+import PolygonStyleFactory from './PolygonStyleFactory';
+/**
+ * Polygon 类用于处理地图上的面要素操作
+ * 包括添加多边形、边框、图片图层、热力图等功能
+ */
+export default class Polygon {
+    /**
+     * 构造函数
+     * @param map OpenLayers 地图实例
+     */
+    constructor(map) {
+        if (!map) {
+            throw new Error('Map instance is required');
+        }
+        this.map = map;
+    }
+    /**
+     * 添加地图边框图层
+     * @param data 图层数据，必须是有效的 GeoJSON 格式
+     * @param options 图层配置选项
+     * @returns 创建的图层实例
+     * @throws 当数据格式无效时抛出错误
+     */
+    addBorderPolygon(data, options) {
+        ValidationUtils.validateGeoJSONData(data);
+        const mergedOptions = {
+            fillColor: 'rgba(255, 255, 255, 0)',
+            ...options
+        };
+        const layer = this.addPolygon(data, mergedOptions);
+        if (mergedOptions.mask) {
+            this.setOutLayer(data);
+        }
+        return layer;
+    }
+    /**
+     * 从URL添加地图边框图层
+     * @param url 数据URL
+     * @param options 图层配置选项
+     * @returns 创建的图层实例
+     * @throws 当数据格式无效时抛出错误
+     */
+    addBorderPolygonByUrl(url, options) {
+        const mergedOptions = {
+            layerName: 'border',
+            fillColor: 'rgba(255, 255, 255, 0)',
+            ...options
+        };
+        const layer = this.addPolygonByUrl(url, mergedOptions);
+        return layer;
+    }
+    /**
+     * 添加多边形图层
+     * @param dataJSON GeoJSON 数据
+     * @param options 图层配置选项
+     * @returns 创建的矢量图层
+     * @throws 当数据格式无效时抛出错误
+     */
+    addPolygon(dataJSON, options) {
+        ValidationUtils.validateGeoJSONData(dataJSON);
+        const mergedOptions = {
+            ...ConfigManager.DEFAULT_POLYGON_OPTIONS,
+            ...options
+        };
+        // 如果指定了图层名称，先移除同名图层
+        if (mergedOptions.layerName) {
+            new MapTools(this.map).removeLayer(mergedOptions.layerName);
+        }
+        const format = new GeoJSON();
+        // 优化：在解析 Feature 时直接注入 layerName，利用解析过程的遍历，避免解析后的二次循环
+        if (mergedOptions.layerName) {
+            const originalReadFeatureFromObject = format.readFeatureFromObject;
+            format.readFeatureFromObject = function (object, options) {
+                const feature = originalReadFeatureFromObject.call(this, object, options);
+                feature.set('layerName', mergedOptions.layerName, true); // true 表示静默设置，不触发事件
+                return feature;
+            };
+        }
+        let features;
+        try {
+            features = format.readFeatures(dataJSON, ProjectionUtils.getGeoJSONReadOptions(mergedOptions));
+        }
+        catch (error) {
+            throw new Error(`Failed to parse GeoJSON data: ${error}`);
+        }
+        const layer = new VectorLayer({
+            properties: {
+                name: mergedOptions.layerName,
+                layerName: mergedOptions.layerName
+            },
+            source: new VectorSource({ features }),
+            style: PolygonStyleFactory.createStyle(mergedOptions),
+            zIndex: mergedOptions.zIndex
+        });
+        layer.setVisible(mergedOptions.visible);
+        this.map.addLayer(layer);
+        // 如果需要适应视图
+        if (mergedOptions.fitView) {
+            this.fitViewToLayer(layer);
+        }
+        return layer;
+    }
+    /**
+     * 从URL添加多边形图层
+     * @param url 数据URL
+     * @param options 图层配置选项
+     * @returns 创建的矢量图层
+     * @throws 当数据格式无效时抛出错误
+     */
+    addPolygonByUrl(url, options) {
+        const mergedOptions = {
+            ...ConfigManager.DEFAULT_POLYGON_OPTIONS,
+            ...options
+        };
+        // 如果指定了图层名称，先移除同名图层
+        if (mergedOptions.layerName) {
+            new MapTools(this.map).removeLayer(mergedOptions.layerName);
+        }
+        const format = new GeoJSON(ProjectionUtils.getGeoJSONReadOptions(mergedOptions));
+        // 优化：在解析 Feature 时直接注入 layerName，利用解析过程的遍历，避免解析后的二次循环
+        if (mergedOptions.layerName) {
+            const originalReadFeatureFromObject = format.readFeatureFromObject;
+            format.readFeatureFromObject = function (object, options) {
+                const feature = originalReadFeatureFromObject.call(this, object, options);
+                feature.set('layerName', mergedOptions.layerName, true); // true 表示静默设置，不触发事件
+                return feature;
+            };
+        }
+        const source = new VectorSource({
+            url,
+            format
+        });
+        const layer = new VectorLayer({
+            properties: {
+                name: mergedOptions.layerName,
+                layerName: mergedOptions.layerName
+            },
+            source,
+            style: PolygonStyleFactory.createStyle(mergedOptions),
+            zIndex: mergedOptions.zIndex
+        });
+        layer.setVisible(mergedOptions.visible);
+        this.map.addLayer(layer);
+        // 如果需要适应视图
+        if (mergedOptions.fitView) {
+            source.once('featuresloadend', () => {
+                this.fitViewToLayer(layer);
+            });
+        }
+        return layer;
+    }
+    /**
+     * 适应图层视图
+     * @param layer 图层对象
+     */
+    fitViewToLayer(layer) {
+        const extent = layer.getSource()?.getExtent();
+        if (extent) {
+            this.map.getView().fit(extent, { duration: 500 });
+        }
+    }
+    /**
+     * 根据数据数组更新某个面颜色
+     * @param layerName 图层名称
+     * @param colorObj 颜色映射对象，键为要素属性值，值为颜色字符串
+     * @param options 配置项
+     * @throws 当图层不存在时抛出错误
+     */
+    updateFeatureColor(layerName, colorObj, options) {
+        ValidationUtils.validateLayerName(layerName);
+        const layers = MapTools.getLayerByLayerName(this.map, layerName);
+        if (layers.length === 0) {
+            throw new Error(`Layer with name '${layerName}' not found`);
+        }
+        const layer = layers[0];
+        if (!(layer instanceof VectorLayer)) {
+            throw new Error(`Layer '${layerName}' is not a vector layer`);
+        }
+        const mergedOptions = {
+            textFont: '14px Calibri,sans-serif',
+            textFillColor: '#FFF',
+            textStrokeWidth: 2,
+            ...options
+        };
+        const features = layer.getSource()?.getFeatures();
+        if (!features) {
+            ErrorHandler.getInstance().warn(`No features found in layer '${layerName}'`);
+            return;
+        }
+        features.forEach((feature) => {
+            PolygonStyleFactory.updateSingleFeatureColor(feature, colorObj, mergedOptions);
+        });
+    }
+    /**
+     * 设置外围蒙版图层
+     *
+     * 详细文档参考 https_blog.csdn.net/?url=https%3A%2F%2Fblog.csdn.net%2Fu012413551%2Farticle%2Fdetails%2F122739501
+     *
+     * @param data
+     * @param options
+     */
+    setOutLayer(data, options) {
+        return PolygonMaskLayer.setOutLayer(this.map, data, options);
+    }
+    /**
+     * 添加图片图层
+     * @param imageData 图片数据，包含url和extent
+     * @param options 配置项
+     * @returns 创建的图片图层
+     * @throws 当数据格式无效时抛出错误
+     */
+    addImageLayer(imageData, options) {
+        return PolygonImageLayer.addImageLayer(this.map, imageData, options);
+    }
+    /**
+     * 添加热力图图层
+     * @param pointData 点数据数组
+     * @param options 热力图配置
+     */
+    addHeatmap(pointData, options) {
+        return PolygonHeatmapLayer.addHeatmap(this.map, pointData, options);
+    }
+    /**
+     * 添加遮罩图层
+     * @param data GeoJSON格式的遮罩数据
+     * @param options 配置项
+     * @returns 创建的遮罩图层
+     * @throws 当数据格式无效时抛出错误
+     */
+    addMaskLayer(data, options) {
+        return PolygonMaskLayer.addMaskLayer(this.map, data, options);
+    }
+    removePolygonLayer(layerName) {
+        new MapTools(this.map).removeLayer(layerName);
+        this[layerName] = null;
+    }
+}

package/core/polygon/PolygonHeatmapLayer.d.ts

@@ -0,0 +1,11 @@
+import Feature from "ol/Feature";
+import Map from "ol/Map";
+import { Heatmap } from "ol/layer";
+import VectorSource from "ol/source/Vector";
+import type { HeatMapOptions, PointData } from "../../types";
+/**
+ * 面热力图辅助类。
+ */
+export default class PolygonHeatmapLayer {
+    static addHeatmap(map: Map, pointData: PointData[], options?: HeatMapOptions): Heatmap<Feature<import("ol/geom").Geometry>, VectorSource<Feature<import("ol/geom").Geometry>>>;
+}

package/core/polygon/PolygonHeatmapLayer.js

@@ -0,0 +1,40 @@
+import Feature from "ol/Feature";
+import { Point } from "ol/geom";
+import { Heatmap } from "ol/layer";
+import VectorSource from "ol/source/Vector";
+import { ConfigManager, MapTools } from "../map";
+/**
+ * 面热力图辅助类。
+ */
+export default class PolygonHeatmapLayer {
+    static addHeatmap(map, pointData, options) {
+        if (options?.layerName) {
+            new MapTools(map).removeLayer(options.layerName);
+        }
+        const mergedOptions = {
+            ...ConfigManager.DEFAULT_HEATMAP_OPTIONS,
+            ...options
+        };
+        const heatmapLayer = new Heatmap({
+            source: new VectorSource(),
+            weight: (feature) => feature.get('weight'),
+            blur: mergedOptions.blur ?? ConfigManager.DEFAULT_HEATMAP_OPTIONS.blur,
+            radius: mergedOptions.radius ?? ConfigManager.DEFAULT_HEATMAP_OPTIONS.radius,
+            zIndex: mergedOptions.zIndex ?? ConfigManager.DEFAULT_HEATMAP_OPTIONS.zIndex,
+            opacity: mergedOptions.opacity ?? ConfigManager.DEFAULT_HEATMAP_OPTIONS.opacity
+        });
+        if (mergedOptions.layerName) {
+            heatmapLayer.set('layerName', mergedOptions.layerName);
+        }
+        map.addLayer(heatmapLayer);
+        const valueKey = mergedOptions.valueKey || ConfigManager.DEFAULT_HEATMAP_VALUE_KEY;
+        const max = Math.max(...pointData.map(item => item[valueKey]));
+        pointData.forEach(item => {
+            heatmapLayer.getSource().addFeature(new Feature({
+                geometry: new Point([item.lgtd, item.lttd]),
+                weight: item[valueKey] / max
+            }));
+        });
+        return heatmapLayer;
+    }
+}

package/core/polygon/PolygonImageLayer.d.ts

@@ -0,0 +1,9 @@
+import Map from "ol/Map";
+import { Image as ImageLayer } from "ol/layer";
+import type { ImageLayerData, PolygonOptions } from "../../types";
+/**
+ * 面图片图层辅助类。
+ */
+export default class PolygonImageLayer {
+    static addImageLayer(map: Map, imageData: ImageLayerData, options?: PolygonOptions): ImageLayer<any>;
+}

package/core/polygon/PolygonImageLayer.js

@@ -0,0 +1,61 @@
+import ImageStatic from "ol/source/ImageStatic";
+import { Image as ImageLayer } from "ol/layer";
+import ValidationUtils from "../../utils/ValidationUtils";
+import { ConfigManager, MapTools } from "../map";
+/**
+ * 面图片图层辅助类。
+ */
+export default class PolygonImageLayer {
+    static addImageLayer(map, imageData, options) {
+        const allowEmptyImg = !imageData.img && !!options?.layerName;
+        ValidationUtils.validateImageData(imageData, allowEmptyImg);
+        const mergedOptions = {
+            ...ConfigManager.DEFAULT_IMAGE_OPTIONS,
+            ...options
+        };
+        if (mergedOptions.layerName) {
+            const existingLayers = MapTools.getLayerByLayerName(map, mergedOptions.layerName);
+            if (existingLayers.length > 0) {
+                const existingLayer = existingLayers[0];
+                if (!imageData.extent) {
+                    existingLayer.setSource(undefined);
+                }
+                else {
+                    const url = imageData.img || existingLayer.getSource()?.getUrl() || '';
+                    existingLayer.setSource(new ImageStatic({
+                        url,
+                        imageExtent: imageData.extent
+                    }));
+                }
+                if (mergedOptions.opacity !== undefined)
+                    existingLayer.setOpacity(mergedOptions.opacity);
+                if (mergedOptions.visible !== undefined)
+                    existingLayer.setVisible(mergedOptions.visible);
+                if (mergedOptions.zIndex !== undefined)
+                    existingLayer.setZIndex(mergedOptions.zIndex);
+                return existingLayer;
+            }
+        }
+        const source = imageData.extent
+            ? new ImageStatic({
+                url: imageData.img || '',
+                imageExtent: imageData.extent
+            })
+            : undefined;
+        const imageLayer = new ImageLayer({
+            source,
+            opacity: mergedOptions.opacity,
+            visible: mergedOptions.visible
+        });
+        imageLayer.set('name', mergedOptions.layerName);
+        imageLayer.set('layerName', mergedOptions.layerName);
+        imageLayer.setZIndex(mergedOptions.zIndex);
+        if (mergedOptions.mapClip && mergedOptions.mapClipData) {
+            const clippedLayer = MapTools.setMapClip(imageLayer, mergedOptions.mapClipData);
+            map.addLayer(clippedLayer);
+            return clippedLayer;
+        }
+        map.addLayer(imageLayer);
+        return imageLayer;
+    }
+}