@antv/l7-layers 2.9.37-alpha.2 → 2.9.37-alpha.3

package/es/core/interface.d.ts

@@ -0,0 +1,225 @@
+import { IAnimateOption, IMapService, ITexture2D } from '@antv/l7-core';
+import { IColorRamp, IImagedata } from '@antv/l7-utils';
+import { styleOffset } from '../core/BaseModel';
+import { anchorType } from '../utils/symbol-layout';
+export declare enum lineStyleType {
+    'solid' = 0,
+    'dash' = 1
+}
+interface ILineArrow {
+    enable: boolean;
+    arrowWidth: number;
+    arrowHeight: number;
+    tailWidth: number;
+}
+export declare enum LinearDir {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal"
+}
+export declare enum TextureBlend {
+    NORMAL = "normal",
+    REPLACE = "replace"
+}
+/**
+ * 基础图层类型定义
+ */
+export interface IBaseLayerStyleOptions {
+    opacity?: number;
+    depth?: boolean;
+    blend?: string;
+    raisingHeight?: number;
+    heightfixed?: boolean;
+    zIndex?: number;
+    mask?: boolean;
+    maskInside?: boolean;
+    usage?: string;
+    color?: string;
+    size?: number;
+}
+export interface ILineLayerStyleOptions extends IBaseLayerStyleOptions {
+    tileOrigin?: number[];
+    coord?: string;
+    lineType?: keyof typeof lineStyleType;
+    dashArray?: [number, number];
+    segmentNumber?: number;
+    forward?: boolean;
+    lineTexture?: boolean;
+    iconStep?: number;
+    iconStepCount?: number;
+    textureBlend?: TextureBlend;
+    linearDir?: LinearDir;
+    sourceColor?: string;
+    targetColor?: string;
+    thetaOffset?: number;
+    globalArcHeight?: number;
+    vertexHeightScale?: number;
+    borderWidth?: number;
+    borderColor?: string;
+    blur?: [number, number, number];
+    arrow?: ILineArrow;
+    rampColors?: IColorRamp;
+    featureId?: string;
+    sourceLayer?: string;
+    enablePicking?: boolean;
+    workerEnabled?: boolean;
+}
+export interface IPointLayerStyleOptions extends IBaseLayerStyleOptions {
+    tileOrigin?: number[];
+    coord?: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    stroke: string;
+    blur?: number;
+    textOffset?: [number, number];
+    textAnchor?: anchorType;
+    spacing?: number;
+    padding?: [number, number];
+    halo?: number;
+    gamma?: number;
+    fontWeight?: string;
+    fontFamily?: string;
+    textAllowOverlap?: boolean;
+    pickLight?: boolean;
+    sourceColor?: string;
+    targetColor?: string;
+    opacityLinear?: {
+        enable: boolean;
+        dir: string;
+    };
+    lightEnable: boolean;
+    offsets?: styleOffset;
+    unit?: string;
+    rotation?: number;
+    speed?: number;
+    featureId?: string;
+    sourceLayer?: string;
+}
+export interface IPolygonLayerStyleOptions extends IBaseLayerStyleOptions {
+    tileOrigin?: number[];
+    coord?: string;
+    opacityLinear?: {
+        enable: boolean;
+        dir: string;
+    };
+    topsurface?: boolean;
+    sidesurface?: boolean;
+    mapTexture?: string;
+    sourceColor?: string;
+    targetColor?: string;
+    pickLight: boolean;
+    waterTexture?: string;
+    speed?: number;
+    watercolor?: string;
+    watercolor2?: string;
+    featureId?: string;
+    sourceLayer?: string;
+}
+export interface IRasterTileLayerStyleOptions extends IBaseLayerStyleOptions {
+    opacity: number;
+}
+export interface IMaskLayerStyleOptions extends IBaseLayerStyleOptions {
+    opacity: number;
+    color: string;
+    sourceLayer?: string;
+}
+export interface IWindLayerStyleOptions extends IBaseLayerStyleOptions {
+    uMin?: number;
+    uMax?: number;
+    vMin?: number;
+    vMax?: number;
+    fadeOpacity?: number;
+    speedFactor?: number;
+    dropRate?: number;
+    dropRateBump?: number;
+    numParticles?: number;
+    rampColors?: {
+        [key: number]: string;
+    };
+    sizeScale?: number;
+}
+export interface IImageLayerStyleOptions extends IBaseLayerStyleOptions {
+    domain?: [number, number];
+    noDataValue?: number;
+    clampLow?: boolean;
+    clampHigh?: boolean;
+    rampColors?: IColorRamp;
+    rampColorsData?: ImageData | IImagedata;
+    colorTexture?: ITexture2D;
+    pixelConstant?: number;
+    pixelConstantR?: number;
+    pixelConstantG?: number;
+    pixelConstantB?: number;
+    pixelConstantRGB?: number;
+}
+export interface ICityBuildLayerStyleOptions {
+    opacity: number;
+    baseColor: string;
+    brightColor: string;
+    windowColor: string;
+    time: number;
+    sweep: {
+        enable: boolean;
+        sweepRadius: number;
+        sweepColor: string;
+        sweepSpeed: number;
+        sweepCenter?: [number, number];
+    };
+}
+export interface IGeometryLayerStyleOptions extends IBaseLayerStyleOptions {
+    mapTexture?: string;
+    terrainTexture?: string;
+    center?: [number, number];
+    width?: number;
+    height?: number;
+    widthSegments?: number;
+    heightSegments?: number;
+    terrainClipHeight?: number;
+    rgb2height?: (r: number, g: number, b: number) => number;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    drawCanvas?: (canvas: HTMLCanvasElement) => void;
+    spriteAnimate?: string;
+    spriteRadius?: number;
+    spriteCount?: number;
+    spriteSpeed?: number;
+    spriteTop?: number;
+    spriteBottom?: number;
+    spriteUpdate?: number;
+    spriteScale?: number;
+    animateOption?: IAnimateOption;
+}
+export declare enum CanvasUpdateType {
+    'ALWAYS' = "always",
+    'DRAGEND' = "dragend"
+}
+export interface IDrawingOnCanvas {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    mapService: IMapService;
+    size: [number, number];
+}
+export interface ICanvasLayerStyleOptions {
+    zIndex: number;
+    update: CanvasUpdateType | string;
+    drawingOnCanvas: (option: IDrawingOnCanvas) => void;
+}
+export interface IHeatMapLayerStyleOptions extends IBaseLayerStyleOptions {
+    intensity: number;
+    radius: number;
+    angle: number;
+    rampColors: IColorRamp;
+    coverage?: number;
+}
+export interface IRasterLayerStyleOptions extends IBaseLayerStyleOptions {
+    colorTexture?: ITexture2D;
+    domain: [number, number];
+    noDataValue: number;
+    clampLow: boolean;
+    clampHigh: boolean;
+    rampColors: IColorRamp;
+    rampColorsData?: ImageData | IImagedata;
+    channelRMax?: number;
+    channelGMax?: number;
+    channelBMax?: number;
+}
+export {};

package/es/core/interface.js

@@ -0,0 +1,30 @@
+export var lineStyleType;
+
+(function (lineStyleType) {
+  lineStyleType[lineStyleType["solid"] = 0] = "solid";
+  lineStyleType[lineStyleType["dash"] = 1] = "dash";
+})(lineStyleType || (lineStyleType = {}));
+
+export var LinearDir;
+
+(function (LinearDir) {
+  LinearDir["VERTICAL"] = "vertical";
+  LinearDir["HORIZONTAL"] = "horizontal";
+})(LinearDir || (LinearDir = {}));
+
+export var TextureBlend;
+/**
+ * 基础图层类型定义
+ */
+
+(function (TextureBlend) {
+  TextureBlend["NORMAL"] = "normal";
+  TextureBlend["REPLACE"] = "replace";
+})(TextureBlend || (TextureBlend = {}));
+
+export var CanvasUpdateType;
+
+(function (CanvasUpdateType) {
+  CanvasUpdateType["ALWAYS"] = "always";
+  CanvasUpdateType["DRAGEND"] = "dragend";
+})(CanvasUpdateType || (CanvasUpdateType = {}));

package/es/core/schema.d.ts

@@ -0,0 +1,27 @@
+/**
+ * BaseLayer Schema
+ */
+declare const _default: {
+    properties: {
+        enablePicking: {
+            type: string;
+        };
+        enableHighlight: {
+            type: string;
+        };
+        highlightColor: {
+            oneOf: ({
+                type: string;
+                items: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            } | {
+                type: string;
+                items?: undefined;
+            })[];
+        };
+    };
+};
+export default _default;

package/es/core/schema.js

@@ -0,0 +1,25 @@
+/**
+ * BaseLayer Schema
+ */
+export default {
+  properties: {
+    enablePicking: {
+      type: 'boolean'
+    },
+    enableHighlight: {
+      type: 'boolean'
+    },
+    highlightColor: {
+      oneOf: [{
+        type: 'array',
+        items: {
+          type: 'number',
+          minimum: 0,
+          maximum: 1
+        }
+      }, {
+        type: 'string'
+      }]
+    }
+  }
+};

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

@@ -0,0 +1,39 @@
+export declare type IPosition = [number, number, number] | [number, number];
+export declare 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 顶点起始角度 调整图形的方向
+ */
+export declare function polygonPath(pointCount: number, start?: 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/es/core/shape/Path.js

@@ -0,0 +1,62 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+var _geometryShape;
+
+export var ShapeType3D;
+
+(function (ShapeType3D) {
+  ShapeType3D["CYLINDER"] = "cylinder";
+  ShapeType3D["SQUARECOLUMN"] = "squareColumn";
+  ShapeType3D["TRIANGLECOLUMN"] = "triangleColumn";
+  ShapeType3D["HEXAGONCOLUMN"] = "hexagonColumn";
+  ShapeType3D["PENTAGONCOLUMN"] = "pentagonColumn";
+})(ShapeType3D || (ShapeType3D = {}));
+
+export var ShapeType2D;
+/**
+ * 生成规则多边形顶点个数
+ * @param pointCount  顶点个数 3 => 三角形
+ * @param start 顶点起始角度 调整图形的方向
+ */
+
+(function (ShapeType2D) {
+  ShapeType2D["CIRCLE"] = "circle";
+  ShapeType2D["SQUARE"] = "square";
+  ShapeType2D["TRIANGLE"] = "triangle";
+  ShapeType2D["HEXAGON"] = "hexagon";
+  ShapeType2D["PENTAGON"] = "pentagon";
+})(ShapeType2D || (ShapeType2D = {}));
+
+export function polygonPath(pointCount) {
+  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var step = Math.PI * 2 / pointCount;
+  var line = [];
+
+  for (var i = 0; i < pointCount; i++) {
+    line.push(step * i + start * Math.PI / 12);
+  }
+
+  var path = line.map(function (t) {
+    var x = Math.sin(t + Math.PI / 4);
+    var y = Math.cos(t + Math.PI / 4);
+    return [x, y, 0];
+  }); // path.push(path[0]);
+
+  return path;
+}
+export function circle() {
+  return polygonPath(30);
+}
+export function square() {
+  return polygonPath(4);
+}
+export function triangle() {
+  return polygonPath(3);
+}
+export function hexagon() {
+  return polygonPath(6, 1);
+}
+export function pentagon() {
+  return polygonPath(5);
+}
+export var geometryShape = (_geometryShape = {}, _defineProperty(_geometryShape, ShapeType2D.CIRCLE, circle), _defineProperty(_geometryShape, ShapeType2D.HEXAGON, hexagon), _defineProperty(_geometryShape, ShapeType2D.TRIANGLE, triangle), _defineProperty(_geometryShape, ShapeType2D.SQUARE, square), _defineProperty(_geometryShape, ShapeType2D.PENTAGON, pentagon), _defineProperty(_geometryShape, ShapeType3D.CYLINDER, circle), _defineProperty(_geometryShape, ShapeType3D.HEXAGONCOLUMN, hexagon), _defineProperty(_geometryShape, ShapeType3D.TRIANGLECOLUMN, triangle), _defineProperty(_geometryShape, ShapeType3D.SQUARECOLUMN, square), _defineProperty(_geometryShape, ShapeType3D.PENTAGONCOLUMN, pentagon), _geometryShape);

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

@@ -0,0 +1,17 @@
+import { 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/es/core/shape/extrude.js

@@ -0,0 +1,148 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { lngLatToMeters } from '@antv/l7-utils';
+import earcut from 'earcut';
+import { vec3 } from 'gl-matrix';
+
+/**
+ * 拉伸多边形顶点，返回拉伸后的顶点信息
+ * @param paths 路径数据组
+ * @param extrude 是否拉伸
+ */
+export default function extrudePolygon(path) {
+  var p1 = path[0][0];
+  var 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);
+  }
+
+  var n = path[0].length;
+  var flattengeo = earcut.flatten(path);
+  var vertices = flattengeo.vertices,
+      dimensions = flattengeo.dimensions;
+  var positions = [];
+  var indexArray = []; // 设置顶部z值
+
+  for (var 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);
+    }
+  }
+
+  var triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  indexArray.push.apply(indexArray, _toConsumableArray(triangles));
+
+  var _loop = function _loop(i) {
+    var prePoint = flattengeo.vertices.slice(i * dimensions, (i + 1) * dimensions);
+    var nextPoint = flattengeo.vertices.slice((i + 1) * dimensions, (i + 2) * dimensions);
+
+    if (nextPoint.length === 0) {
+      nextPoint = flattengeo.vertices.slice(0, dimensions);
+    }
+
+    var 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.apply(indexArray, _toConsumableArray([0, 2, 1, 2, 3, 1].map(function (v) {
+      return v + indexOffset;
+    })));
+  };
+
+  for (var i = 0; i < n; i++) {
+    _loop(i);
+  }
+
+  return {
+    positions: positions,
+    index: indexArray
+  };
+}
+export function fillPolygon(points) {
+  var flattengeo = earcut.flatten(points);
+  var triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  return {
+    positions: flattengeo.vertices,
+    index: triangles
+  };
+}
+export function extrude_PolygonNormal(path) {
+  var needFlat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var p1 = path[0][0];
+  var 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);
+  }
+
+  var n = path[0].length;
+  var flattengeo = earcut.flatten(path);
+  var vertices = flattengeo.vertices,
+      dimensions = flattengeo.dimensions;
+  var positions = [];
+  var indexArray = [];
+  var normals = []; // 设置顶部z值 position uv
+
+  for (var j = 0; j < vertices.length / dimensions; j++) {
+    if (dimensions === 2) {
+      positions.push(vertices[j * 2], vertices[j * 2 + 1], 1, -1, -1);
+    } else {
+      positions.push(vertices[j * 3], vertices[j * 3 + 1], 1, -1, -1);
+    }
+
+    normals.push(0, 0, 1);
+  }
+
+  var triangles = earcut(flattengeo.vertices, flattengeo.holes, flattengeo.dimensions);
+  indexArray.push.apply(indexArray, _toConsumableArray(triangles));
+
+  var _loop2 = function _loop2(i) {
+    var prePoint = flattengeo.vertices.slice(i * dimensions, (i + 1) * dimensions);
+    var nextPoint = flattengeo.vertices.slice((i + 1) * dimensions, (i + 2) * dimensions);
+
+    if (nextPoint.length === 0) {
+      nextPoint = flattengeo.vertices.slice(0, dimensions);
+    }
+
+    var indexOffset = positions.length / 5;
+    positions.push(prePoint[0], prePoint[1], 1, 0, 0, nextPoint[0], nextPoint[1], 1, 0.1, 0, prePoint[0], prePoint[1], 0, 0, 0.8, nextPoint[0], nextPoint[1], 0, 0.1, 0.8);
+    var normal = computeVertexNormals([nextPoint[0], nextPoint[1], 1], [prePoint[0], prePoint[1], 0], [prePoint[0], prePoint[1], 1], needFlat);
+    normals.push.apply(normals, _toConsumableArray(normal).concat(_toConsumableArray(normal), _toConsumableArray(normal), _toConsumableArray(normal)));
+    indexArray.push.apply(indexArray, _toConsumableArray([1, 2, 0, 3, 2, 1].map(function (v) {
+      return v + indexOffset;
+    })));
+  };
+
+  for (var i = 0; i < n; i++) {
+    _loop2(i);
+  }
+
+  return {
+    positions: positions,
+    index: indexArray,
+    normals: normals
+  };
+}
+
+function computeVertexNormals(p1, p2, p3) {
+  var needFlat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var cb = vec3.create();
+  var ab = vec3.create();
+  var normal = vec3.create();
+
+  if (needFlat) {
+    p1 = lngLatToMeters(p1);
+    p2 = lngLatToMeters(p2);
+    p3 = lngLatToMeters(p3);
+  }
+
+  var pA = vec3.fromValues.apply(vec3, _toConsumableArray(p1));
+  var pB = vec3.fromValues.apply(vec3, _toConsumableArray(p2));
+  var pC = vec3.fromValues.apply(vec3, _toConsumableArray(p3));
+  vec3.sub(cb, pC, pB);
+  vec3.sub(ab, pA, pB);
+  vec3.cross(normal, cb, ab);
+  var newNormal = vec3.create();
+  vec3.normalize(newNormal, normal);
+  return newNormal;
+}

package/es/core/triangulation.d.ts

@@ -0,0 +1,130 @@
+import { 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 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, segmentNumber?: number): {
+    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[];
+};