@antv/l7-layers 2.25.7 → 2.25.10

package/lib/core/schema.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * BaseLayer Schema
+ */
+var _default = exports.default = {
+  properties: {
+    enablePicking: {
+      type: 'boolean'
+    },
+    enableHighlight: {
+      type: 'boolean'
+    },
+    highlightColor: {
+      oneOf: [{
+        type: 'array',
+        items: {
+          type: 'number',
+          minimum: 0,
+          maximum: 1
+        }
+      }, {
+        type: 'string'
+      }]
+    }
+  }
+};

package/lib/core/shape/Path.d.ts

@@ -0,0 +1,40 @@
+export type IPosition = [number, number, number] | [number, number];
+export type IPath = IPosition[];
+export declare enum ShapeType3D {
+    CYLINDER = "cylinder",
+    SQUARECOLUMN = "squareColumn",
+    TRIANGLECOLUMN = "triangleColumn",
+    HEXAGONCOLUMN = "hexagonColumn",
+    PENTAGONCOLUMN = "pentagonColumn"
+}
+export declare enum ShapeType2D {
+    CIRCLE = "circle",
+    SQUARE = "square",
+    TRIANGLE = "triangle",
+    HEXAGON = "hexagon",
+    PENTAGON = "pentagon"
+}
+/**
+ * 生成规则多边形顶点个数
+ * @param pointCount  顶点个数 3 => 三角形
+ * @param start 顶点起始角度 调整图形的方向
+ * @param angleOffset 额外的角度偏移，用于调整六边形方向
+ */
+export declare function polygonPath(pointCount: number, start?: number, angleOffset?: number): IPath;
+export declare function circle(): IPath;
+export declare function square(): IPath;
+export declare function triangle(): IPath;
+export declare function hexagon(): IPath;
+export declare function pentagon(): IPath;
+export declare const geometryShape: {
+    circle: typeof circle;
+    hexagon: typeof hexagon;
+    triangle: typeof triangle;
+    square: typeof square;
+    pentagon: typeof pentagon;
+    cylinder: typeof circle;
+    hexagonColumn: typeof hexagon;
+    triangleColumn: typeof triangle;
+    squareColumn: typeof square;
+    pentagonColumn: typeof pentagon;
+};

package/lib/core/shape/Path.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ShapeType3D = exports.ShapeType2D = void 0;
+exports.circle = circle;
+exports.geometryShape = void 0;
+exports.hexagon = hexagon;
+exports.pentagon = pentagon;
+exports.polygonPath = polygonPath;
+exports.square = square;
+exports.triangle = triangle;
+let ShapeType3D = exports.ShapeType3D = /*#__PURE__*/function (ShapeType3D) {
+  ShapeType3D["CYLINDER"] = "cylinder";
+  ShapeType3D["SQUARECOLUMN"] = "squareColumn";
+  ShapeType3D["TRIANGLECOLUMN"] = "triangleColumn";
+  ShapeType3D["HEXAGONCOLUMN"] = "hexagonColumn";
+  ShapeType3D["PENTAGONCOLUMN"] = "pentagonColumn";
+  return ShapeType3D;
+}({});
+let ShapeType2D = exports.ShapeType2D = /*#__PURE__*/function (ShapeType2D) {
+  ShapeType2D["CIRCLE"] = "circle";
+  ShapeType2D["SQUARE"] = "square";
+  ShapeType2D["TRIANGLE"] = "triangle";
+  ShapeType2D["HEXAGON"] = "hexagon";
+  ShapeType2D["PENTAGON"] = "pentagon";
+  return ShapeType2D;
+}({});
+/**
+ * 生成规则多边形顶点个数
+ * @param pointCount  顶点个数 3 => 三角形
+ * @param start 顶点起始角度 调整图形的方向
+ * @param angleOffset 额外的角度偏移，用于调整六边形方向
+ */
+function polygonPath(pointCount, start = 0, angleOffset = Math.PI / 4) {
+  const step = Math.PI * 2 / pointCount;
+  const line = [];
+  for (let i = 0; i < pointCount; i++) {
+    line.push(step * i + start * Math.PI / 12);
+  }
+  const path = line.map(t => {
+    const x = Math.sin(t + angleOffset);
+    const y = Math.cos(t + angleOffset);
+    return [x, y, 0];
+  });
+  // path.push(path[0]);
+  return path;
+}
+function circle() {
+  return polygonPath(30);
+}
+function square() {
+  return polygonPath(4);
+}
+function triangle() {
+  return polygonPath(3);
+}
+function hexagon() {
+  // 生成 pointy-top 六边形（尖角朝上）
+  // 使用 angleOffset = 0 并翻转 y 方向，以匹配 d3-hexbin 的方向
+  // d3-hexbin 在屏幕坐标系中 y 向下为正，使用 y = -cos(angle)
+  // 我们需要翻转 y 坐标以确保蜂窝网格闭合
+  const path = polygonPath(6, 0, 0);
+  return path.map(p => [p[0], -p[1], p[2]]);
+}
+function pentagon() {
+  return polygonPath(5);
+}
+const geometryShape = exports.geometryShape = {
+  [ShapeType2D.CIRCLE]: circle,
+  [ShapeType2D.HEXAGON]: hexagon,
+  [ShapeType2D.TRIANGLE]: triangle,
+  [ShapeType2D.SQUARE]: square,
+  [ShapeType2D.PENTAGON]: pentagon,
+  [ShapeType3D.CYLINDER]: circle,
+  [ShapeType3D.HEXAGONCOLUMN]: hexagon,
+  [ShapeType3D.TRIANGLECOLUMN]: triangle,
+  [ShapeType3D.SQUARECOLUMN]: square,
+  [ShapeType3D.PENTAGONCOLUMN]: pentagon
+};

package/lib/core/shape/arrow.d.ts

@@ -0,0 +1,25 @@
+import type { ArrowType, IArrowOptions, ILineSymbol } from '../interface';
+export interface IArrowData {
+    vertices: number[];
+    indices: number[];
+    outLineIndices: number[];
+    dimensions: number;
+    offset?: number[];
+    normals: number[];
+}
+export type arrowPosition = -1 | 1;
+export declare function halfTriangleArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function triangleArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function rectArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function diamondArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function classicArrow(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function circleArraw(dir: arrowPosition, options: IArrowOptions): IArrowData;
+export declare function lineArrowPath(coord: number[], indexOffset: number | undefined, symbol: ILineSymbol): IArrowData;
+export declare function getSymbol(type: ArrowType | IArrowOptions, position: 'source' | 'target'): IArrowData | {
+    vertices: never[];
+    indices: never[];
+    normals: never[];
+    dimensions: number;
+    outLineIndices: never[];
+    outLineNormals: never[];
+};

package/lib/core/shape/arrow.js

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.circleArraw = circleArraw;
+exports.classicArrow = classicArrow;
+exports.diamondArrow = diamondArrow;
+exports.getSymbol = getSymbol;
+exports.halfTriangleArrow = halfTriangleArrow;
+exports.lineArrowPath = lineArrowPath;
+exports.rectArrow = rectArrow;
+exports.triangleArrow = triangleArrow;
+var _earcut = _interopRequireDefault(require("earcut"));
+var _Path = require("./Path");
+const maxArrowWidthMap = {
+  circle: 2,
+  triangle: 2,
+  diamond: 4,
+  rect: 2,
+  classic: 3,
+  halfTriangle: 2,
+  none: 0
+};
+const PathHeight = 1 / 2;
+function halfTriangleArrow(dir, options) {
+  const {
+    width = 2,
+    height = 1
+  } = options;
+  return {
+    vertices: [0, PathHeight * dir, 1 * dir * width, -(height + PathHeight) * dir, 1 * dir * width, (height - PathHeight) * dir, 0, PathHeight * dir, 1 * dir * width, -(height + PathHeight) * dir, 1 * dir * width, (height - PathHeight) * dir],
+    indices: [3, 4, 5],
+    outLineIndices: [0, 1, 2],
+    normals: [1 * dir, -2 * dir, 1,
+    // y,x
+    -2 * dir, 1.5 * dir, 1, 1 * dir, 1.5 * dir, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+function triangleArrow(dir, options) {
+  const {
+    width = 2,
+    height = 3
+  } = options;
+  return {
+    vertices: [0, 0, 1 * dir * width, 1 * height, 1 * dir * width, -1 * height, 0, 0, 1 * dir * width, 1 * height, 1 * dir * width, -1 * height],
+    outLineIndices: [0, 1, 2],
+    indices: [3, 4, 5],
+    normals: [0, -1.5 * dir, 1, 2, 1 * dir, 1, -2, 1 * dir, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+function rectArrow(dir, options) {
+  const {
+    width = 2,
+    height = 2
+  } = options;
+  return {
+    vertices: [0, height / 2, dir * width * 1, height / 2, dir * width * 1, -height / 2, 0, -height / 2, 0, height / 2, dir * width * 1, height / 2, dir * width * 1, -height / 2, 0, -height / 2],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+function diamondArrow(dir, options) {
+  const {
+    width = 2,
+    height = 3
+  } = options;
+  return {
+    vertices: [0, 0, 1 * width * dir, 0.5 * height, 2 * width * dir, 0, 1 * width * dir, -0.5 * height, 0, 0, 1 * width * dir, 0.5 * height, 2 * width * dir, 0, 1 * width * dir, -0.5 * height],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+function classicArrow(dir, options) {
+  const {
+    width = 2,
+    height = 3
+  } = options;
+  return {
+    vertices: [0, 0, 2 * dir * width, 1 * height, 1.5 * dir * width, 0, 2 * dir * width, -1 * height, 0, 0, 2 * dir * width, 1 * height, 1.5 * dir * width, 0, 2 * dir * width, -1 * height],
+    dimensions: 2,
+    indices: [4, 5, 6, 4, 6, 7],
+    outLineIndices: [0, 1, 2, 0, 2, 3],
+    normals: [0, -dir, 1, 1, 0, 1, 0, -dir, 1, -1, -0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  };
+}
+function circleArraw(dir, options) {
+  const {
+    width = 2,
+    height = 2
+  } = options;
+  const path = (0, _Path.circle)();
+  const flattengeo = _earcut.default.flatten([path]);
+  const triangles = (0, _earcut.default)(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  // @ts-ignore
+  const vertice = path.map(t => [t[0] * width * dir, t[1] * height]).flat();
+  return {
+    vertices: [...vertice, ...vertice],
+    dimensions: 2,
+    indices: triangles.map(v => v + path.length),
+    outLineIndices: triangles,
+    normals: [
+    // @ts-ignore
+    ...path.map(t => [t[1] * height, t[0] * width * dir, 1]).flat(), ...new Array(path.length * 3).fill(0)]
+  };
+}
+function lineArrowPath(coord, indexOffset = 0, symbol) {
+  const sourceType = typeof symbol['source'] === 'object' ? symbol['source'].type : symbol['source'];
+  const targetType = typeof symbol['target'] === 'object' ? symbol['target'].type : symbol['target'];
+  const {
+    width: sourceWidth = sourceType ? maxArrowWidthMap[sourceType] : 0
+  } = typeof symbol['source'] === 'object' ? symbol['source'] : {};
+  const {
+    width: targetWidth = targetType ? maxArrowWidthMap[targetType] : 0
+  } = typeof symbol['target'] === 'object' ? symbol['target'] : {};
+  return {
+    vertices: [0, PathHeight, 1 * sourceWidth, ...coord, 1, PathHeight, -1 * targetWidth, ...coord, 1, -PathHeight, -1 * targetWidth, ...coord, 0, -PathHeight, 1 * sourceWidth, ...coord, 0, PathHeight, 1 * sourceWidth, ...coord, 1, PathHeight, -1 * targetWidth, ...coord, 1, -PathHeight, -1 * targetWidth, ...coord, 0, -PathHeight, 1 * sourceWidth, ...coord],
+    outLineIndices: [0, 1, 2, 0, 2, 3].map(t => t + indexOffset),
+    indices: [4, 5, 6, 4, 6, 7].map(t => t + indexOffset),
+    normals: [1, -1, 1, 1, 1, 1, -1, 0, 1, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    dimensions: 2
+  };
+}
+function getSymbol(type, position) {
+  const shape = typeof type === 'object' ? type.type : type;
+  const dir = position === 'source' ? 1 : -1;
+  const option = typeof type === 'object' ? type : {};
+  switch (shape) {
+    case 'circle':
+      return circleArraw(dir, option);
+    case 'triangle':
+      return triangleArrow(dir, option);
+    case 'diamond':
+      return diamondArrow(dir, option);
+    case 'rect':
+      return rectArrow(dir, option);
+    case 'classic':
+      return classicArrow(dir, option);
+    case 'halfTriangle':
+      return halfTriangleArrow(dir, option);
+    default:
+      return {
+        vertices: [],
+        indices: [],
+        normals: [],
+        dimensions: 2,
+        outLineIndices: [],
+        outLineNormals: []
+      };
+  }
+}

package/lib/core/shape/extrude.d.ts

@@ -0,0 +1,17 @@
+import type { IPath } from './Path';
+export interface IExtrudeGeomety {
+    positions: number[];
+    index: number[];
+    normals?: number[];
+}
+/**
+ * 拉伸多边形顶点，返回拉伸后的顶点信息
+ * @param paths 路径数据组
+ * @param extrude 是否拉伸
+ */
+export default function extrudePolygon(path: IPath[]): IExtrudeGeomety;
+export declare function fillPolygon(points: IPath[]): {
+    positions: number[];
+    index: number[];
+};
+export declare function extrude_PolygonNormal(path: IPath[], needFlat?: boolean): IExtrudeGeomety;

package/lib/core/shape/extrude.js

@@ -0,0 +1,142 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = extrudePolygon;
+exports.extrude_PolygonNormal = extrude_PolygonNormal;
+exports.fillPolygon = fillPolygon;
+var _l7Utils = require("@antv/l7-utils");
+var _earcut = _interopRequireDefault(require("earcut"));
+var _glMatrix = require("gl-matrix");
+var _utils = require("../utils");
+/**
+ * 拉伸多边形顶点，返回拉伸后的顶点信息
+ * @param paths 路径数据组
+ * @param extrude 是否拉伸
+ */
+function extrudePolygon(path) {
+  const p1 = path[0][0];
+  const p2 = path[0][path[0].length - 1];
+  if (p1[0] === p2[0] && p1[1] === p2[1]) {
+    path[0] = path[0].slice(0, path[0].length - 1);
+  }
+  const n = path[0].length;
+  const flattengeo = _earcut.default.flatten(path);
+  const {
+    vertices,
+    dimensions
+  } = flattengeo;
+  const positions = [];
+  const indexArray = [];
+  // 设置顶部z值
+  for (let j = 0; j < vertices.length / dimensions; j++) {
+    if (dimensions === 2) {
+      positions.push(vertices[j * 2], vertices[j * 2 + 1], 1);
+    } else {
+      positions.push(vertices[j * 3], vertices[j * 3 + 1], 1);
+    }
+  }
+  const triangles = (0, _earcut.default)(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  indexArray.push(...triangles);
+  for (let i = 0; i < n; i++) {
+    const prePoint = flattengeo.vertices.slice(i * dimensions, (i + 1) * dimensions);
+    let nextPoint = flattengeo.vertices.slice((i + 1) * dimensions, (i + 2) * dimensions);
+    if (nextPoint.length === 0) {
+      nextPoint = flattengeo.vertices.slice(0, dimensions);
+    }
+    const indexOffset = positions.length / 3;
+    positions.push(prePoint[0], prePoint[1], 1, nextPoint[0], nextPoint[1], 1, prePoint[0], prePoint[1], 0, nextPoint[0], nextPoint[1], 0);
+    indexArray.push(...[0, 2, 1, 2, 3, 1].map(v => v + indexOffset));
+  }
+  return {
+    positions,
+    index: indexArray
+  };
+}
+function fillPolygon(points) {
+  const flattengeo = _earcut.default.flatten(points);
+  const triangles = (0, _earcut.default)(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  return {
+    positions: flattengeo.vertices,
+    index: triangles
+  };
+}
+function extrude_PolygonNormal(path, needFlat = false // 是否需要转成平面坐标
+) {
+  const p1 = path[0][0];
+  const p2 = path[0][path[0].length - 1];
+  if (p1[0] === p2[0] && p1[1] === p2[1]) {
+    path[0] = path[0].slice(0, path[0].length - 1);
+  }
+  const n = path[0].length;
+  const flattengeo = _earcut.default.flatten(path);
+  const {
+    vertices,
+    dimensions,
+    holes
+  } = flattengeo;
+  const positions = [];
+  const indexArray = [];
+  const normals = [];
+  // 设置顶部z值 position uv
+  for (let j = 0; j < vertices.length / dimensions; j++) {
+    positions.push(vertices[j * dimensions],
+    // x
+    vertices[j * dimensions + 1],
+    // y
+    1,
+    // z
+    -1,
+    // 顶部uv
+    -1 // 顶部uv
+    );
+    normals.push(0, 0, 1);
+  }
+  const indices = (0, _utils.getPolygonSurfaceIndices)(vertices, holes, dimensions, needFlat);
+  indexArray.push(...indices);
+
+  // 设置侧面
+  for (let i = 0; i < n; i++) {
+    const prePoint = flattengeo.vertices.slice(i * dimensions, (i + 1) * dimensions);
+    let nextPoint = flattengeo.vertices.slice((i + 1) * dimensions, (i + 2) * dimensions);
+    if (nextPoint.length === 0) {
+      nextPoint = flattengeo.vertices.slice(0, dimensions);
+    }
+    const indexOffset = positions.length / 5;
+    // 侧面四顶点
+    positions.push(prePoint[0], prePoint[1], 1, 0, 0, nextPoint[0], nextPoint[1], 1, 0.1,
+    // 侧面 低uv
+    0,
+    // 侧面低 uv
+    prePoint[0], prePoint[1], 0, 0, 0.8, nextPoint[0], nextPoint[1], 0, 0.1, 0.8);
+    const normal = computeVertexNormals([nextPoint[0], nextPoint[1], 1], [prePoint[0], prePoint[1], 0], [prePoint[0], prePoint[1], 1], needFlat);
+    normals.push(...normal, ...normal, ...normal, ...normal);
+    indexArray.push(...[1, 2, 0, 3, 2, 1].map(v => v + indexOffset));
+  }
+  return {
+    positions,
+    index: indexArray,
+    normals
+  };
+}
+function computeVertexNormals(p1, p2, p3, needFlat = false) {
+  const cb = _glMatrix.vec3.create();
+  const ab = _glMatrix.vec3.create();
+  const normal = _glMatrix.vec3.create();
+  if (needFlat) {
+    p1 = (0, _l7Utils.lngLatToMeters)(p1);
+    p2 = (0, _l7Utils.lngLatToMeters)(p2);
+    p3 = (0, _l7Utils.lngLatToMeters)(p3);
+  }
+  const pA = _glMatrix.vec3.fromValues(...p1);
+  const pB = _glMatrix.vec3.fromValues(...p2);
+  const pC = _glMatrix.vec3.fromValues(...p3);
+  _glMatrix.vec3.sub(cb, pC, pB);
+  _glMatrix.vec3.sub(ab, pA, pB);
+  _glMatrix.vec3.cross(normal, cb, ab);
+  const newNormal = _glMatrix.vec3.create();
+  _glMatrix.vec3.normalize(newNormal, normal);
+  return newNormal;
+}

package/lib/core/triangulation.d.ts

@@ -0,0 +1,136 @@
+import type { IEncodeFeature } from '@antv/l7-core';
+/**
+ * 计算2D 填充点图顶点
+ * @param feature 映射feature
+ */
+export declare function PointFillTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+/**
+ * 计算2D 填充点图顶点 (地球模式)
+ * @param feature 映射feature
+ */
+export declare function GlobelPointFillTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+/**
+ * 计算3D 拉伸点图
+ * @param feature 映射feature
+ */
+export declare function PointExtrudeTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    normals: number[] | undefined;
+    size: number;
+};
+/**
+ * 计算图片标注
+ * @param feature 映射feature
+ */
+export declare function PointImageTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+/**
+ * 线三角化
+ * @param feature 映射feature
+ */
+export declare function LineTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    normals: number[];
+    indexes: number[];
+    size: number;
+};
+export declare function FlowLineFillTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function SimpleLineTriangulation(feature: IEncodeFeature): {
+    vertices: any[];
+    indices: never[];
+    normals: never[];
+    size: number;
+    count: number;
+};
+export declare function TileSimpleLineTriangulation(feature: IEncodeFeature): {
+    vertices: any[];
+    indices: never[];
+    size: number;
+    count: number;
+};
+export declare function polygonTriangulation(feature: IEncodeFeature): {
+    indices: number[];
+    vertices: number[];
+    size: number;
+};
+export declare function polygonTriangulationWithCenter(feature: IEncodeFeature): {
+    indices: number[];
+    vertices: number[];
+    size: number;
+};
+export declare function PolygonExtrudeTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    normals: number[] | undefined;
+    size: number;
+};
+export declare function HeatmapGridTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+/**
+ * 图片图层顶点构造
+ * @param feature 数据
+ */
+export declare function RasterImageTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+/**
+ *  计算3D弧线顶点
+ * @param feature 映射数据
+ * @param segNum 弧线线段数
+ */
+export declare function LineArcTriangulation(feature: IEncodeFeature, styleOption?: unknown): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+/**
+ * 构建热力图密度图的顶点
+ * @param feature
+ * @returns
+ */
+export declare function HeatmapTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+};
+export declare function computeVertexNormals(positions: number[], indexArray: number[], dim?: number, needFlat?: boolean): Float32Array;
+export declare function checkIsClosed(points: number[][][]): boolean;
+/**
+ * 构建地球三角网格
+ * @returns
+ */
+export declare function earthTriangulation(): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+    normals: number[];
+};
+export declare function earthOuterTriangulation(): {
+    vertices: number[];
+    indices: number[];
+    size: number;
+    normals: number[];
+};