bbj-screen-widget 2.4.62 → 2.4.64

package/esm2015/lib/custom-baidu-map/baidu-fence/baidu-fence.component.js

@@ -0,0 +1,400 @@
+import { __awaiter, __decorate, __metadata, __param } from "tslib";
+import { Component, EventEmitter } from '@angular/core';
+import { BaseLayer } from '../base-layer';
+import { Data, Method, Property, Widget, Event, Param } from 'bbj-widget-base';
+import { Subject } from 'rxjs';
+const EARTH_RADIUS = 6371393;
+const ɵ0 = { type: 'string', title: 'ID' };
+let BaiduFenceComponent = class BaiduFenceComponent extends BaseLayer {
+    constructor() {
+        super(...arguments);
+        // @Property('标签字体', { ui: { widget: 'myFont', visibleIf: { showLabel: [true] } } })
+        // textFont: any = {
+        //   family: '',
+        //   color: '#000000',
+        //   weight: 'normal',
+        //   size: 16,
+        //   space: 0,
+        //   lineHeight: 0,
+        // };
+        this.lineWidth = 2;
+        this.lineColor = 'rgb(50, 133, 255)';
+        this.fillColor = 'rgba(248, 231, 28, 0.2)';
+        this.showDrawButton = true;
+        this.data = [
+            {
+                // name: '多边形',
+                type: 'polygon',
+                lnglat: '120.7,28;120.8,28;120.8,27.9;120.7,27.9',
+            },
+            {
+                // name: '圆形',
+                type: 'circle',
+                lnglat: '120.6,27.9',
+                radius: 5000,
+            },
+        ];
+        this.create = new EventEmitter();
+        this.editData = [];
+        this.stopEdit$ = new Subject();
+    }
+    ngOnInit() {
+        const _super = Object.create(null, {
+            ngOnInit: { get: () => super.ngOnInit }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.ngOnInit.call(this);
+            // await this.parent.init$;
+            // this.startDraw();
+        });
+    }
+    ngOnDestroy() {
+        var _a;
+        super.ngOnDestroy();
+        this.stopDraw();
+        (_a = this.scene) === null || _a === void 0 ? void 0 : _a.clearData();
+    }
+    createLayers() {
+        this.layer = new mapvgl.PolygonLayer({
+            renderOrder: -1,
+            lineColor: this.lineColor,
+            lineWidth: this.lineWidth,
+            fillColor: this.fillColor,
+        });
+        // this.textLayer = new mapvgl.TextLayer({
+        //   renderOrder: -1,
+        //   ...this.getTextOptions(this.textFont),
+        // });
+        return [this.layer];
+    }
+    updateData() {
+        const data = [];
+        this.data.forEach((r) => {
+            if (r.type === 'circle') {
+                // const radius = (r.radius * 180) / EARTH_RADIUS / Math.PI;
+                // // let radius = cradius / 90;
+                // let pointNum = 90;
+                // let startAngle = 0;
+                // let endAngle = Math.PI * 2;
+                // let points = [];
+                // const lnglat = r.lnglat.split(',');
+                // const lng = +lnglat[0];
+                // const lat = +lnglat[1];
+                // for (var i = 0; i <= pointNum; i++) {
+                //   const angle = startAngle + ((endAngle - startAngle) * i) / pointNum;
+                //   const x = lng + (radius * Math.cos(angle)) / Math.abs(Math.cos((lat * Math.PI) / 180));
+                //   const y = lat + radius * Math.sin(angle);
+                //   points.push([x, y]);
+                // }
+                // data.push({
+                //   geometry: {
+                //     type: 'Polygon',
+                //     coordinates: [points],
+                //   },
+                // });
+                let pointsCount = 90;
+                const radius = r.radius;
+                const lnglat = r.lnglat.split(',');
+                const centerLng = +lnglat[0];
+                const centerLat = +lnglat[1];
+                // 转换中心点纬度为弧度
+                const centerLatRad = (centerLat * Math.PI) / 180;
+                // 存储轨迹点的数组
+                const trajectory = [];
+                // 遍历 0~360°，生成等间隔的点
+                for (let i = 0; i < pointsCount; i++) {
+                    // 计算当前点的方位角（弧度）：从0°到360°，均分pointsCount份
+                    const angleRad = (i * 360 / pointsCount) * Math.PI / 180;
+                    // 计算当前点相对于中心点的经纬度增量（弧度）
+                    const deltaLatRad = (radius * Math.cos(angleRad)) / EARTH_RADIUS;
+                    const deltaLngRad = (radius * Math.sin(angleRad)) / (EARTH_RADIUS * Math.cos(centerLatRad));
+                    // 转换为角度，并计算新坐标
+                    const newLat = centerLat + (deltaLatRad * 180) / Math.PI;
+                    const newLng = centerLng + (deltaLngRad * 180) / Math.PI;
+                    // 添加到轨迹数组（保留6位小数，经纬度常规精度）
+                    trajectory.push([parseFloat(newLng.toFixed(6)), parseFloat(newLat.toFixed(6))]);
+                }
+                data.push({
+                    geometry: {
+                        type: 'Polygon',
+                        coordinates: [trajectory],
+                    },
+                });
+            }
+            else {
+                const coordinates = r.lnglat.split(';').map((r) => {
+                    const lnglat = r.split(',');
+                    return [+lnglat[0], +lnglat[1]];
+                });
+                data.push({
+                    geometry: {
+                        type: 'Polygon',
+                        coordinates: [coordinates],
+                    },
+                });
+            }
+        });
+        this.layer.setData(data);
+    }
+    startDraw(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { DrawScene, PolygonDraw, CircleDraw, OperateEventType } = yield import('bmap-draw');
+            if (!this.scene) {
+                this.scene = new DrawScene(this.parent.map, { noLimit: true });
+                this.scene.addEventListener(OperateEventType.COMPLETE, (e) => {
+                    console.log(e);
+                    if (e.target.overlay.radius) {
+                        const radius = e.target.overlay.radius;
+                        const lnglat = e.target.overlay.latLng;
+                        const data = {
+                            type: 'circle',
+                            lnglat: `${lnglat.lng},${lnglat.lat}`,
+                            radius: radius,
+                        };
+                        this.data.push(data);
+                        this.updateData();
+                        this.create.emit(data);
+                    }
+                    else {
+                        const points = e.target.overlay.getPoints();
+                        if (!this.data) {
+                            this.data = [];
+                        }
+                        const data = {
+                            type: 'polygon',
+                            lnglat: points.map((p) => `${p.latLng.lng},${p.latLng.lat}`).join(';'),
+                        };
+                        this.create.emit(data);
+                    }
+                });
+            }
+            switch (type) {
+                case 'polygon':
+                    if (!this.polygon) {
+                        this.polygon = new PolygonDraw(this.scene, {
+                            autoViewport: true,
+                            hideTip: false,
+                            isSeries: true,
+                            isOpen: true,
+                            baseOpts: {
+                                fillColor: this.fillColor,
+                                strokeWeight: this.lineWidth,
+                                strokeColor: this.lineColor,
+                            },
+                        });
+                    }
+                    this.polygon.open();
+                    break;
+                case 'circle':
+                    if (!this.circle) {
+                        this.circle = new CircleDraw(this.scene, {
+                            autoViewport: true,
+                            isOpen: true,
+                            isSeries: true,
+                            // labelOptions: {
+                            //   borderRadius: '2px',
+                            //   background: '#b5d3fb',
+                            //   border: '1px solid #b5d3fb',
+                            //   color: '#333',
+                            //   fontSize: '12px',
+                            //   letterSpacing: '0',
+                            //   padding: '5px',
+                            // },
+                            baseOpts: {
+                                fillColor: this.fillColor,
+                                strokeWeight: this.lineWidth,
+                                strokeColor: this.lineColor,
+                            },
+                        });
+                    }
+                    this.circle.open();
+                    break;
+            }
+            // this.stopDraw();
+            // this.editData = [];
+            // this.editLayer = new mapvgl.IconLayer({
+            //   width: 20 / 2,
+            //   height: 30.6 / 2,
+            //   offset: [0, -30.6 / 2 / 2],
+            //   icon: 'assets/img/screen/marker.png',
+            //   enablePicked: true, // 是否可以拾取
+            //   selectedIndex: -1, // 选中项
+            //   selectedColor: '#ff0000', // 选中项颜色
+            //   autoSelect: true, // 根据鼠标位置来自动设置选中项
+            //   onRightClick: (e) => {
+            //     console.log('right click', e);
+            //     this.editData.splice(e.dataIndex, 1);
+            //     this.updateEditData();
+            //   },
+            // });
+            // this.parent.addLayer(this.editLayer);
+            // this.editLineLayer = new mapvgl.SimpleLineLayer({
+            //   color: 'rgba(50, 50, 200, 1)',
+            //   blend: 'lighter',
+            //   data: [
+            //     {
+            //       geometry: {
+            //         type: 'LineString',
+            //         coordinates: [
+            //           [116.394191, 39.91334],
+            //           [116.417259, 39.913672],
+            //         ],
+            //       },
+            //     },
+            //   ],
+            // });
+            // this.parent.addLayer(this.editLineLayer);
+            // this.parent.mapClick.pipe(takeUntil(this.stopEdit$)).subscribe((point) => {
+            //   this.editData.push([point.lng, point.lat]);
+            //   // this.editData.push({
+            //   //   geometry: {
+            //   //     type: 'Point',
+            //   //     coordinates: [point.lng, point.lat],
+            //   //   },
+            //   // });
+            //   this.updateEditData();
+            // });
+        });
+    }
+    updateEditData() {
+        if (this.editLayer) {
+            this.editLayer.setData(this.editData.map((r) => ({ geometry: { type: 'Point', coordinates: r } })));
+        }
+        if (this.editLineLayer) {
+            this.editLineLayer.setData([
+                {
+                    geometry: {
+                        type: 'LineString',
+                        coordinates: this.editData,
+                    },
+                },
+            ]);
+        }
+    }
+    stopDraw() {
+        var _a;
+        (_a = this.scene) === null || _a === void 0 ? void 0 : _a.close();
+        // this.stopEdit$.next();
+        // if (this.editLayer) {
+        //   this.parent.removeLayer(this.editLayer);
+        //   this.editLayer = null;
+        // }
+        // if (this.editLineLayer) {
+        //   this.parent.removeLayer(this.editLineLayer);
+        //   this.editLineLayer = null;
+        // }
+        // if (this.editData?.length >= 3) {
+        //   if (!this.data) {
+        //     this.data = [];
+        //   }
+        //   const data = {
+        //     type: 'polygon',
+        //     lnglat: this.editData.map((r) => r.join(',')).join(';'),
+        //   };
+        //   this.data.push(data);
+        //   this.updateData();
+        //   this.create.emit(data);
+        // }
+        // this.editData = null;
+    }
+    search() {
+        if (!this.searchText) {
+        }
+        var local = new BMapGL.LocalSearch(this.parent.map, {
+            //智能搜索
+            onSearchComplete: (res) => {
+                console.log(res, local);
+            },
+        });
+        local.search(this.searchText);
+    }
+};
+BaiduFenceComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'sc-baidu-fence',
+                template: "<ng-container *ngIf=\"showDrawButton\">\n  <button nz-button (click)=\"startDraw('polygon')\">\u7ED8\u5236\u591A\u8FB9\u5F62</button>\n  <button nz-button (click)=\"startDraw('circle')\">\u7ED8\u5236\u5706\u5F62</button>\n  <button nz-button (click)=\"stopDraw()\">\u7ED3\u675F\u7ED8\u5236</button>\n</ng-container>\n\n<!-- <input type=\"text\" placeholder=\"\u8BF7\u8F93\u5165\u5730\u70B9\" [(ngModel)]=\"searchText\" />\n<button nz-button (click)=\"search()\">\u67E5\u8BE2</button> -->\n",
+                styles: [":host{position:absolute;display:block;left:0;top:0;z-index:100;padding:12px}button{transition:none}"]
+            },] }
+];
+__decorate([
+    Property('线条宽度', {
+        ui: { widget: 'myRange', min: 1, max: 40, step: 1 },
+    }),
+    __metadata("design:type", Object)
+], BaiduFenceComponent.prototype, "lineWidth", void 0);
+__decorate([
+    Property('线条颜色', {
+        type: 'string',
+        ui: {
+            widget: 'myColor',
+        },
+    }),
+    __metadata("design:type", Object)
+], BaiduFenceComponent.prototype, "lineColor", void 0);
+__decorate([
+    Property('填充颜色', {
+        type: 'string',
+        ui: {
+            widget: 'myColor',
+        },
+    }),
+    __metadata("design:type", Object)
+], BaiduFenceComponent.prototype, "fillColor", void 0);
+__decorate([
+    Property('显示绘制按钮', { type: 'boolean' }),
+    __metadata("design:type", Object)
+], BaiduFenceComponent.prototype, "showDrawButton", void 0);
+__decorate([
+    Data({
+        properties: {
+            id: ɵ0,
+            // name: { type: 'string', title: '围栏名称' },
+            type: { type: 'string', title: '围栏类型' },
+            lnglat: { type: 'string', title: '经纬度' },
+            radius: { type: 'number', title: '半径' },
+        },
+    }),
+    __metadata("design:type", Array)
+], BaiduFenceComponent.prototype, "data", void 0);
+__decorate([
+    Event('新增围栏', {
+        params: {
+            properties: {
+                type: { type: 'string', title: '围栏类型' },
+                lnglat: { type: 'string', title: '经纬度' },
+                radius: { type: 'number', title: '半径' },
+            },
+        },
+    }),
+    __metadata("design:type", Object)
+], BaiduFenceComponent.prototype, "create", void 0);
+__decorate([
+    Method('开始绘制'),
+    __param(0, Param('类型', {
+        type: 'string',
+        enum: [
+            { label: '多边形', value: 'polygon' },
+            { label: '圆形', value: 'circle' },
+        ],
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], BaiduFenceComponent.prototype, "startDraw", null);
+__decorate([
+    Method('结束绘制'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], BaiduFenceComponent.prototype, "stopDraw", null);
+BaiduFenceComponent = __decorate([
+    Widget('电子围栏', {
+        group: 'component',
+        image: '',
+        icon: '',
+        hidden: true,
+    })
+], BaiduFenceComponent);
+export { BaiduFenceComponent };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"baidu-fence.component.js","sourceRoot":"","sources":["../../../../../../projects/screen-widget/src/lib/custom-baidu-map/baidu-fence/baidu-fence.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, OnDestroy, OnInit } from '@angular/core';\nimport { BaseLayer } from '../base-layer';\nimport { Data, Method, Property, Widget, Event, Param } from 'bbj-widget-base';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { DrawScene, RectDraw } from 'bmap-draw';\ndeclare const mapvgl;\ndeclare const BMapGL;\nconst EARTH_RADIUS = 6371393;\n@Component({\n  selector: 'sc-baidu-fence',\n  templateUrl: './baidu-fence.component.html',\n  styleUrls: ['./baidu-fence.component.less'],\n})\n@Widget('电子围栏', {\n  group: 'component',\n  image: '',\n  icon: '',\n  hidden: true,\n})\nexport class BaiduFenceComponent extends BaseLayer implements OnInit, OnDestroy {\n  // @Property('标签字体', { ui: { widget: 'myFont', visibleIf: { showLabel: [true] } } })\n  // textFont: any = {\n  //   family: '',\n  //   color: '#000000',\n  //   weight: 'normal',\n  //   size: 16,\n  //   space: 0,\n  //   lineHeight: 0,\n  // };\n  @Property('线条宽度', {\n    ui: { widget: 'myRange', min: 1, max: 40, step: 1 },\n  })\n  lineWidth = 2;\n  @Property('线条颜色', {\n    type: 'string',\n    ui: {\n      widget: 'myColor',\n    },\n  })\n  lineColor = 'rgb(50, 133, 255)';\n  @Property('填充颜色', {\n    type: 'string',\n    ui: {\n      widget: 'myColor',\n    },\n  })\n  fillColor = 'rgba(248, 231, 28, 0.2)';\n  @Property('显示绘制按钮', { type: 'boolean' })\n  showDrawButton = true;\n  @Data({\n    properties: {\n      id: { type: 'string', title: 'ID' },\n      // name: { type: 'string', title: '围栏名称' },\n      type: { type: 'string', title: '围栏类型' },\n      lnglat: { type: 'string', title: '经纬度' },\n      radius: { type: 'number', title: '半径' },\n    },\n  })\n  data: any[] = [\n    {\n      // name: '多边形',\n      type: 'polygon',\n      lnglat: '120.7,28;120.8,28;120.8,27.9;120.7,27.9',\n    },\n    {\n      // name: '圆形',\n      type: 'circle',\n      lnglat: '120.6,27.9',\n      radius: 5000,\n    },\n  ];\n  @Event('新增围栏', {\n    params: {\n      properties: {\n        type: { type: 'string', title: '围栏类型' },\n        lnglat: { type: 'string', title: '经纬度' },\n        radius: { type: 'number', title: '半径' },\n      },\n    },\n  })\n  create = new EventEmitter<any>();\n  layer: any;\n  textLayer: any;\n  editLayer: any;\n  editData = [];\n  stopEdit$ = new Subject<void>();\n  editLineLayer: any;\n  searchText: string;\n  polygon: any;\n  circle: any;\n  scene: any;\n  async ngOnInit(): Promise<void> {\n    super.ngOnInit();\n    // await this.parent.init$;\n    // this.startDraw();\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n    this.stopDraw();\n    this.scene?.clearData();\n  }\n\n  createLayers(): any[] {\n    this.layer = new mapvgl.PolygonLayer({\n      renderOrder: -1,\n      lineColor: this.lineColor,\n      lineWidth: this.lineWidth,\n      fillColor: this.fillColor,\n    });\n    // this.textLayer = new mapvgl.TextLayer({\n    //   renderOrder: -1,\n    //   ...this.getTextOptions(this.textFont),\n    // });\n    return [this.layer];\n  }\n  updateData(): void {\n    const data = [];\n    this.data.forEach((r) => {\n      if (r.type === 'circle') {\n        // const radius = (r.radius * 180) / EARTH_RADIUS / Math.PI;\n        // // let radius = cradius / 90;\n        // let pointNum = 90;\n        // let startAngle = 0;\n        // let endAngle = Math.PI * 2;\n        // let points = [];\n        // const lnglat = r.lnglat.split(',');\n        // const lng = +lnglat[0];\n        // const lat = +lnglat[1];\n        // for (var i = 0; i <= pointNum; i++) {\n        //   const angle = startAngle + ((endAngle - startAngle) * i) / pointNum;\n        //   const x = lng + (radius * Math.cos(angle)) / Math.abs(Math.cos((lat * Math.PI) / 180));\n        //   const y = lat + radius * Math.sin(angle);\n        //   points.push([x, y]);\n        // }\n        // data.push({\n        //   geometry: {\n        //     type: 'Polygon',\n        //     coordinates: [points],\n        //   },\n        // });\n        let pointsCount = 90;\n        const radius = r.radius;\n        const lnglat = r.lnglat.split(',');\n        const centerLng = +lnglat[0];\n        const centerLat = +lnglat[1];\n        // 转换中心点纬度为弧度\n        const centerLatRad = (centerLat * Math.PI) / 180;\n        // 存储轨迹点的数组\n        const trajectory = [];\n\n        // 遍历 0~360°，生成等间隔的点\n        for (let i = 0; i < pointsCount; i++) {\n          // 计算当前点的方位角（弧度）：从0°到360°，均分pointsCount份\n          const angleRad = (i * 360 / pointsCount) * Math.PI / 180;\n\n          // 计算当前点相对于中心点的经纬度增量（弧度）\n          const deltaLatRad = (radius * Math.cos(angleRad)) / EARTH_RADIUS;\n          const deltaLngRad = (radius * Math.sin(angleRad)) / (EARTH_RADIUS * Math.cos(centerLatRad));\n\n          // 转换为角度，并计算新坐标\n          const newLat = centerLat + (deltaLatRad * 180) / Math.PI;\n          const newLng = centerLng + (deltaLngRad * 180) / Math.PI;\n\n          // 添加到轨迹数组（保留6位小数，经纬度常规精度）\n          trajectory.push([parseFloat(newLng.toFixed(6)), parseFloat(newLat.toFixed(6))]);\n        }\n        data.push({\n          geometry: {\n            type: 'Polygon',\n            coordinates: [trajectory],\n          },\n        });\n      } else {\n        const coordinates = r.lnglat.split(';').map((r) => {\n          const lnglat = r.split(',');\n          return [+lnglat[0], +lnglat[1]];\n        });\n        data.push({\n          geometry: {\n            type: 'Polygon',\n            coordinates: [coordinates],\n          },\n        });\n      }\n    });\n\n    this.layer.setData(data);\n  }\n\n  @Method('开始绘制')\n  async startDraw(\n    @Param('类型', {\n      type: 'string',\n      enum: [\n        { label: '多边形', value: 'polygon' },\n        { label: '圆形', value: 'circle' },\n      ],\n    })\n    type: string,\n  ) {\n    const { DrawScene, PolygonDraw, CircleDraw, OperateEventType } = await import('bmap-draw');\n    if(!this.scene){\n      this.scene = new DrawScene(this.parent.map, { noLimit: true });\n      \n      this.scene.addEventListener(OperateEventType.COMPLETE, (e) => {\n      console.log(e);\n      if (e.target.overlay.radius) {\n        const radius = e.target.overlay.radius;\n        const lnglat = e.target.overlay.latLng;\n        const data = {\n          type: 'circle',\n          lnglat: `${lnglat.lng},${lnglat.lat}`,\n          radius: radius,\n        };\n        this.data.push(data);\n        this.updateData();\n        this.create.emit(data);\n      } else {\n        const points = e.target.overlay.getPoints();\n        if (!this.data) {\n          this.data = [];\n        }\n        const data = {\n          type: 'polygon',\n          lnglat: points.map((p) => `${p.latLng.lng},${p.latLng.lat}`).join(';'),\n        };\n        this.create.emit(data);\n      }\n    });\n    }\n    switch (type) {\n      case 'polygon':\n        if (!this.polygon) {\n          this.polygon = new PolygonDraw(this.scene, {\n            autoViewport: true, // 是否自动调整视野\n            hideTip: false, // 隐藏绘制提示\n            isSeries: true, // 是否开启批量绘制\n            isOpen: true,\n            baseOpts: {\n              fillColor: this.fillColor,\n              strokeWeight: this.lineWidth,\n              strokeColor: this.lineColor,\n              // strokeOpacity: 1,\n              // fillOpacity: 0.2,\n            },\n          });\n        }\n        this.polygon.open();\n        break;\n      case 'circle':\n        if (!this.circle) {\n          this.circle = new CircleDraw(this.scene, {\n            autoViewport: true, // 是否自动调整视野\n            isOpen: true,\n            isSeries: true, // 是否开启批量绘制\n            // labelOptions: {\n            //   borderRadius: '2px',\n            //   background: '#b5d3fb',\n            //   border: '1px solid #b5d3fb',\n            //   color: '#333',\n            //   fontSize: '12px',\n            //   letterSpacing: '0',\n            //   padding: '5px',\n            // },\n            baseOpts: {\n              fillColor: this.fillColor,\n              strokeWeight: this.lineWidth,\n              strokeColor: this.lineColor,\n            },\n          });\n        }\n        this.circle.open();\n        break;\n    }\n\n    // this.stopDraw();\n    // this.editData = [];\n    // this.editLayer = new mapvgl.IconLayer({\n    //   width: 20 / 2,\n    //   height: 30.6 / 2,\n    //   offset: [0, -30.6 / 2 / 2],\n    //   icon: 'assets/img/screen/marker.png',\n    //   enablePicked: true, // 是否可以拾取\n    //   selectedIndex: -1, // 选中项\n    //   selectedColor: '#ff0000', // 选中项颜色\n    //   autoSelect: true, // 根据鼠标位置来自动设置选中项\n    //   onRightClick: (e) => {\n    //     console.log('right click', e);\n    //     this.editData.splice(e.dataIndex, 1);\n    //     this.updateEditData();\n    //   },\n    // });\n    // this.parent.addLayer(this.editLayer);\n    // this.editLineLayer = new mapvgl.SimpleLineLayer({\n    //   color: 'rgba(50, 50, 200, 1)',\n    //   blend: 'lighter',\n    //   data: [\n    //     {\n    //       geometry: {\n    //         type: 'LineString',\n    //         coordinates: [\n    //           [116.394191, 39.91334],\n    //           [116.417259, 39.913672],\n    //         ],\n    //       },\n    //     },\n    //   ],\n    // });\n    // this.parent.addLayer(this.editLineLayer);\n    // this.parent.mapClick.pipe(takeUntil(this.stopEdit$)).subscribe((point) => {\n    //   this.editData.push([point.lng, point.lat]);\n    //   // this.editData.push({\n    //   //   geometry: {\n    //   //     type: 'Point',\n    //   //     coordinates: [point.lng, point.lat],\n    //   //   },\n    //   // });\n    //   this.updateEditData();\n    // });\n  }\n\n  updateEditData() {\n    if (this.editLayer) {\n      this.editLayer.setData(this.editData.map((r) => ({ geometry: { type: 'Point', coordinates: r } })));\n    }\n    if (this.editLineLayer) {\n      this.editLineLayer.setData([\n        {\n          geometry: {\n            type: 'LineString',\n            coordinates: this.editData,\n          },\n        },\n      ]);\n    }\n  }\n\n  @Method('结束绘制')\n  stopDraw() {\n    this.scene?.close();\n    // this.stopEdit$.next();\n    // if (this.editLayer) {\n    //   this.parent.removeLayer(this.editLayer);\n    //   this.editLayer = null;\n    // }\n    // if (this.editLineLayer) {\n    //   this.parent.removeLayer(this.editLineLayer);\n    //   this.editLineLayer = null;\n    // }\n    // if (this.editData?.length >= 3) {\n    //   if (!this.data) {\n    //     this.data = [];\n    //   }\n    //   const data = {\n    //     type: 'polygon',\n    //     lnglat: this.editData.map((r) => r.join(',')).join(';'),\n    //   };\n    //   this.data.push(data);\n    //   this.updateData();\n    //   this.create.emit(data);\n    // }\n    // this.editData = null;\n  }\n\n  search() {\n    if (!this.searchText) {\n    }\n    var local = new BMapGL.LocalSearch(this.parent.map, {\n      //智能搜索\n      onSearchComplete: (res) => {\n        console.log(res, local);\n      },\n    });\n    local.search(this.searchText);\n  }\n}\n"]}